openAgent

1export * as Integration from "./integration"
2 
3import { Schema } from "effect"
4import { optional } from "./schema"
5import { define, inventory } from "./event"
6import { Connection } from "./connection"
7import { ascending } from "./identifier"
8import { statics } from "./schema"
9import { IntegrationID, IntegrationMethodID } from "./integration-id"
10 
11export const ID = IntegrationID
12export type ID = typeof ID.Type
13 
14export const MethodID = IntegrationMethodID
15export type MethodID = typeof MethodID.Type
16 
17export interface When extends Schema.Schema.Type<typeof When> {}
18export const When = Schema.Struct({
19  key: Schema.String,
20  op: Schema.Literals(["eq", "neq"]),
21  value: Schema.String,
22}).annotate({ identifier: "Integration.When" })
23 
24export interface TextPrompt extends Schema.Schema.Type<typeof TextPrompt> {}
25export const TextPrompt = Schema.Struct({
26  type: Schema.Literal("text"),
27  key: Schema.String,
28  message: Schema.String,
29  placeholder: optional(Schema.String),
30  when: optional(When),
31}).annotate({ identifier: "Integration.TextPrompt" })
32 
33export interface SelectPrompt extends Schema.Schema.Type<typeof SelectPrompt> {}
34export const SelectPrompt = Schema.Struct({
35  type: Schema.Literal("select"),
36  key: Schema.String,
37  message: Schema.String,
38  options: Schema.Array(
39    Schema.Struct({
40      label: Schema.String,
41      value: Schema.String,
42      hint: optional(Schema.String),
43    }),
44  ),
45  when: optional(When),
46}).annotate({ identifier: "Integration.SelectPrompt" })
47 
48export const Prompt = Schema.Union([TextPrompt, SelectPrompt]).pipe(Schema.toTaggedUnion("type"))
49export type Prompt = typeof Prompt.Type
50 
51export interface OAuthMethod extends Schema.Schema.Type<typeof OAuthMethod> {}
52export const OAuthMethod = Schema.Struct({
53  id: MethodID,
54  type: Schema.Literal("oauth"),
55  label: Schema.String,
56  prompts: optional(Schema.Array(Prompt)),
57}).annotate({ identifier: "Integration.OAuthMethod" })
58 
59export interface KeyMethod extends Schema.Schema.Type<typeof KeyMethod> {}
60export const KeyMethod = Schema.Struct({
61  type: Schema.Literal("key"),
62  label: optional(Schema.String),
63}).annotate({ identifier: "Integration.KeyMethod" })
64 
65export interface EnvMethod extends Schema.Schema.Type<typeof EnvMethod> {}
66export const EnvMethod = Schema.Struct({
67  type: Schema.Literal("env"),
68  names: Schema.Array(Schema.String),
69}).annotate({ identifier: "Integration.EnvMethod" })
70 
71export const Method = Schema.Union([OAuthMethod, KeyMethod, EnvMethod])
72  .pipe(Schema.toTaggedUnion("type"))
73  .annotate({ identifier: "Integration.Method" })
74export type Method = typeof Method.Type
75 
76export const Inputs = Schema.Record(Schema.String, Schema.String).annotate({ identifier: "Integration.Inputs" })
77export type Inputs = typeof Inputs.Type
78 
79const Updated = define({
80  type: "integration.updated",
81  schema: {},
82})
83const ConnectionUpdated = define({
84  type: "integration.connection.updated",
85  schema: { integrationID: ID },
86})
87export const Event = { Updated, ConnectionUpdated, Definitions: inventory(Updated, ConnectionUpdated) }
88 
89export interface Ref extends Schema.Schema.Type<typeof Ref> {}
90export const Ref = Schema.Struct({
91  id: ID,
92  name: Schema.String,
93}).annotate({ identifier: "Integration.Ref" })
94 
95export class Info extends Schema.Class<Info>("Integration.Info")({
96  id: ID,
97  name: Schema.String,
98  methods: Schema.Array(Method),
99  connections: Schema.Array(Connection.Info),
100}) {}
101 
102export const AttemptID = Schema.String.pipe(
103  Schema.brand("Integration.AttemptID"),
104  statics((schema) => ({ create: () => schema.make("con_" + ascending()) })),
105)
106export type AttemptID = typeof AttemptID.Type
107 
108const AttemptTime = Schema.Struct({
109  created: Schema.Number,
110  expires: Schema.Number,
111})
112 
113export class Attempt extends Schema.Class<Attempt>("Integration.Attempt")({
114  attemptID: AttemptID,
115  url: Schema.String,
116  instructions: Schema.String,
117  mode: Schema.Literals(["auto", "code"]),
118  time: AttemptTime,
119}) {}
120 
121export const AttemptStatus = Schema.Union([
122  Schema.Struct({ status: Schema.Literal("pending"), time: AttemptTime }),
123  Schema.Struct({ status: Schema.Literal("complete"), time: AttemptTime }),
124  Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String, time: AttemptTime }),
125  Schema.Struct({ status: Schema.Literal("expired"), time: AttemptTime }),
126])
127  .pipe(Schema.toTaggedUnion("status"))
128  .annotate({ identifier: "Integration.AttemptStatus" })
129export type AttemptStatus = typeof AttemptStatus.Type
130