@automate.ax/integration-contracts 0.147.1 → 0.150.0

package/src/kit/schemas.ts

@@ -0,0 +1,93 @@
+/* oxlint-disable typescript/no-unsafe-type-assertion -- Generated operation keys index a frozen external contract. */
+import { Validator } from "@cfworker/json-schema"
+import * as z from "zod"
+import { KIT_OPENAPI_DATA } from "./openapi-operations.generated"
+import type { KitOperationKey } from "./operation-manifest"
+import type { KitOperationInput, KitOperationOutput } from "./types"
+
+export interface KitRuntimeParameter {
+  explode: boolean
+  name: string
+  providerName: string
+  style: string
+}
+
+/** Frozen runtime description of one public Kit operation. */
+export interface KitRuntimeOperation {
+  bodyParameters: string[]
+  bodyWireSchema?: Record<string, unknown>
+  inputSchema: Record<string, unknown>
+  method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT"
+  outputSchema: Record<string, unknown>
+  outputWireSchema: Record<string, unknown>
+  path: string
+  pathParameters: KitRuntimeParameter[]
+  queryParameters: KitRuntimeParameter[]
+  responseMode: "json" | "void"
+}
+
+/** Runtime Kit contract narrowed once from the opaque generated payload. */
+const operationData = KIT_OPENAPI_DATA as {
+  definitions: Record<string, Record<string, unknown>>
+  operations: Record<string, unknown>
+  wireDefinitions: Record<string, Record<string, unknown>>
+}
+const OPERATIONS = operationData.operations as unknown as Record<
+  KitOperationKey,
+  KitRuntimeOperation
+>
+const VALIDATOR = new Validator(
+  {
+    $defs: operationData.definitions,
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    additionalProperties: false,
+    properties: Object.fromEntries(
+      Object.entries(OPERATIONS).flatMap(([key, operation]) => [
+        [`${key}:input`, operation.inputSchema],
+        [`${key}:output`, operation.outputSchema],
+      ]),
+    ),
+    type: "object",
+  },
+  "2020-12",
+)
+
+/**
+ * Returns the immutable runtime descriptor for one Kit operation.
+ *
+ * @param key Public operation name.
+ */
+export function kitOperation<TKey extends KitOperationKey>(key: TKey) {
+  return OPERATIONS[key]
+}
+
+/**
+ * Validates flattened public input for one Kit operation.
+ *
+ * @param key Public operation name.
+ */
+export function kitOperationInputSchema<TKey extends KitOperationKey>(
+  key: TKey,
+): z.ZodType<KitOperationInput<TKey>> {
+  return z.custom<KitOperationInput<TKey>>(
+    (value) => VALIDATOR.validate({ [`${key}:input`]: value }).valid,
+    { message: `Input does not match Kit operation ${key}.` },
+  )
+}
+
+/**
+ * Validates a public successful response for one Kit operation.
+ *
+ * @param key Public operation name.
+ */
+export function kitOperationOutputSchema<TKey extends KitOperationKey>(
+  key: TKey,
+): z.ZodType<KitOperationOutput<TKey>> {
+  return z.custom<KitOperationOutput<TKey>>(
+    (value) => VALIDATOR.validate({ [`${key}:output`]: value }).valid,
+    { message: `Output does not match Kit operation ${key}.` },
+  )
+}
+
+/** Provider-native component schemas used for schema-guided key mapping. */
+export const KIT_WIRE_DEFINITIONS = operationData.wireDefinitions

package/src/kit/types.ts

@@ -0,0 +1,87 @@
+import type { Encodable } from "@automate.ax/codec"
+import type { KitOperationMap } from "./openapi-types.generated"
+import type { KitOperationKey } from "./operation-manifest"
+
+type Operation<TKey extends KitOperationKey> =
+  TKey extends keyof KitOperationMap ? KitOperationMap[TKey] : never
+
+/** Converts absent generated operation sections into intersection identities. */
+type InputPart<TValue> = [NonNullable<TValue>] extends [never]
+  ? unknown
+  : NonNullable<TValue>
+
+type Parameters<TOperation, TLocation extends string> = TOperation extends {
+  parameters?: infer TParameters
+}
+  ? TLocation extends keyof NonNullable<TParameters>
+    ? InputPart<NonNullable<TParameters>[TLocation]>
+    : unknown
+  : unknown
+
+/** Extracts the JSON request body from one generated operation. */
+type JsonBody<TOperation> = TOperation extends { requestBody?: infer TBody }
+  ? [NonNullable<TBody>] extends [never]
+    ? unknown
+    : NonNullable<TBody> extends { content: infer TContent }
+      ? "application/json" extends keyof TContent
+        ? TContent["application/json"]
+        : unknown
+      : unknown
+  : unknown
+
+/** Extracts the JSON response body from one generated response. */
+type JsonResponse<TResponse> = TResponse extends { content: infer TContent }
+  ? "application/json" extends keyof TContent
+    ? TContent["application/json"]
+    : object
+  : object
+
+/** Extracts the union of successful generated operation responses. */
+type SuccessResponse<TOperation> = TOperation extends {
+  responses: infer TResponses
+}
+  ? JsonResponse<
+      TResponses[Extract<keyof TResponses, 200 | 201 | 202 | 203 | 204>]
+    >
+  : never
+
+/** Materializes an intersection as one readable object type. */
+type Simplify<TValue> = { [TKey in keyof TValue]: TValue[TKey] } & {}
+
+type EncodableValue<TValue> = unknown extends TValue
+  ? Encodable
+  : TValue extends undefined | null | boolean | number | string
+    ? TValue
+    : TValue extends readonly (infer TItem)[]
+      ? EncodableValue<TItem>[]
+      : TValue extends object
+        ? keyof TValue extends never
+          ? Record<string, Encodable>
+          : { [TKey in keyof TValue]: EncodableValue<TValue[TKey]> }
+        : never
+
+/** Flattens one generated operation's path, query, and body fields. */
+type RawKitOperationInput<TKey extends KitOperationKey> = Simplify<
+  Parameters<Operation<TKey>, "path"> &
+    Parameters<Operation<TKey>, "query"> &
+    JsonBody<Operation<TKey>>
+>
+
+/** Preserves operation unions and rejects fields on truly empty inputs. */
+type PublicInput<TValue> = TValue extends unknown
+  ? keyof TValue extends never
+    ? Record<string, never>
+    : {
+        [TField in keyof TValue]: EncodableValue<TValue[TField]>
+      }
+  : never
+
+/** Flattened camelCase input for one frozen Kit V4 operation. */
+export type KitOperationInput<TKey extends KitOperationKey> = PublicInput<
+  RawKitOperationInput<TKey>
+>
+
+/** CamelCase successful response for one frozen Kit V4 operation. */
+export type KitOperationOutput<TKey extends KitOperationKey> = EncodableValue<
+  SuccessResponse<Operation<TKey>>
+>

package/src/krisp/api.ts

@@ -0,0 +1,215 @@
+import type { Encodable } from "@automate.ax/codec"
+import { encodableSchema } from "@automate.ax/codec"
+import * as z from "zod"
+
+const KRISP_API_BASE_URL = "https://meeting-api.krisp.ai/v1/"
+const KRISP_API_ORIGIN = new URL(KRISP_API_BASE_URL).origin
+const KRISP_SECRET_SCHEMA = z.object({ apiKey: z.string().min(1) })
+
+/** Options for one authenticated Krisp REST request. */
+export interface KrispRequestOptions<TSchema extends z.ZodType> {
+  /** Public camelCase JSON body. */
+  body?: Encodable
+
+  /** HTTP verb. Defaults to `GET`. */
+  method?: "GET" | "POST"
+
+  /** Public camelCase query parameters. */
+  query?: Record<
+    string,
+    boolean | number | readonly string[] | string | undefined
+  >
+
+  /** Schema for the normalized provider response. */
+  responseSchema: TSchema
+}
+
+/** Structured Krisp REST failure. */
+export class KrispApiError extends Error {
+  /** Normalized provider error payload, when valid JSON was returned. */
+  readonly body?: Encodable
+
+  /** Retry delay in seconds, when Krisp returned one. */
+  readonly retryAfter?: number
+
+  /** HTTP status returned by Krisp. */
+  readonly status: number
+
+  /**
+   * Creates a structured Krisp API error.
+   *
+   * @param options - Provider status, body, and retry metadata.
+   * @param options.body - Normalized provider error body.
+   * @param options.retryAfter - Retry delay in seconds.
+   * @param options.status - HTTP status.
+   */
+  constructor(options: {
+    body?: Encodable
+    retryAfter?: number
+    status: number
+  }) {
+    super(
+      getErrorMessage(options.body) ??
+        `Krisp API request failed with status ${options.status}.`,
+    )
+    this.name = "KrispApiError"
+    this.body = options.body
+    this.retryAfter = options.retryAfter
+    this.status = options.status
+  }
+}
+
+/**
+ * Creates an authenticated Krisp Meeting Assistant REST client.
+ *
+ * @param secret - Resolved Krisp API-key secret.
+ */
+export function getKrispApi(secret: Record<string, unknown>) {
+  const { apiKey } = KRISP_SECRET_SCHEMA.parse(secret)
+
+  return {
+    /**
+     * Runs one Krisp request and returns its normalized response.
+     *
+     * @param path - API path relative to the v1 root.
+     * @param options - Method, parameters, and response schema.
+     */
+    async request<TSchema extends z.ZodType>(
+      path: string,
+      options: KrispRequestOptions<TSchema>,
+    ): Promise<z.output<TSchema>> {
+      const url = new URL(path.replace(/^\//, ""), KRISP_API_BASE_URL)
+      if (url.origin !== KRISP_API_ORIGIN) {
+        throw new Error("Krisp API paths must use the Krisp API origin.")
+      }
+      for (const [name, value] of Object.entries(options.query ?? {})) {
+        if (value === undefined) continue
+        url.searchParams.set(
+          toSnakeCase(name),
+          Array.isArray(value) ? value.join(",") : String(value),
+        )
+      }
+      const response = await fetch(url, {
+        body:
+          options.body === undefined
+            ? undefined
+            : JSON.stringify(toKrisp(options.body)),
+        headers: {
+          Accept: "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          ...(options.body === undefined
+            ? {}
+            : { "Content-Type": "application/json" }),
+        },
+        method: options.method ?? "GET",
+      })
+      const normalized = fromKrisp(parseJson(await response.text()))
+      if (!response.ok) {
+        const body = encodableSchema.safeParse(normalized)
+        throw new KrispApiError({
+          ...(body.success && { body: body.data }),
+          retryAfter: parseFiniteNumber(response.headers.get("Retry-After")),
+          status: response.status,
+        })
+      }
+      return options.responseSchema.parse(normalized)
+    },
+  }
+}
+
+/**
+ * Converts public camelCase JSON to Krisp wire keys.
+ *
+ * @param value - Public value to normalize.
+ */
+export function toKrisp(value: Encodable): Encodable {
+  if (value instanceof Date) return value.toISOString()
+  if (Array.isArray(value)) return value.map(toKrisp)
+  if (!isPlainObject(value)) return value
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [
+      toSnakeCase(key),
+      toKrisp(item),
+    ]),
+  )
+}
+
+/**
+ * Converts Krisp wire JSON to public camelCase keys.
+ *
+ * @param value - Provider value to normalize.
+ */
+export function fromKrisp(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(fromKrisp)
+  if (!isPlainObject(value)) return value
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [
+      toCamelCase(key),
+      fromKrisp(item),
+    ]),
+  )
+}
+
+/**
+ * Checks whether a value is a key-value object.
+ *
+ * @param value - Candidate value.
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+/**
+ * Parses a JSON response body without obscuring the HTTP status on failure.
+ *
+ * @param value - Raw response text.
+ */
+function parseJson(value: string): unknown {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Parses an optional finite numeric header.
+ *
+ * @param value - Raw header value.
+ */
+function parseFiniteNumber(value: string | null) {
+  if (value === null) return undefined
+  const number = Number(value)
+  return Number.isFinite(number) ? number : undefined
+}
+
+/**
+ * Extracts Krisp's human-readable error string.
+ *
+ * @param body - Normalized provider error body.
+ */
+function getErrorMessage(body: Encodable | undefined) {
+  return isPlainObject(body) && typeof body.error === "string"
+    ? body.error
+    : undefined
+}
+
+/**
+ * Converts one public camelCase key to Krisp snake_case.
+ *
+ * @param value - Public key.
+ */
+function toSnakeCase(value: string) {
+  return value.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
+}
+
+/**
+ * Converts one Krisp snake_case key to public camelCase.
+ *
+ * @param value - Provider key.
+ */
+function toCamelCase(value: string) {
+  return value.replace(/_([a-z0-9])/g, (_, letter: string) =>
+    letter.toUpperCase(),
+  )
+}

package/src/krisp/index.ts

@@ -0,0 +1,2 @@
+export * from "./api"
+export * from "./schemas"

package/src/krisp/schemas.ts

@@ -0,0 +1,122 @@
+import * as z from "zod"
+import type { Encodable } from "@automate.ax/codec"
+
+const DATE_TIME_SCHEMA = z.iso.datetime({ offset: true })
+
+/** Krisp profile represented by a personal API key. */
+export const KRISP_PROFILE_SCHEMA = z.object({
+  avatar: z.url().nullable().prefault(null),
+  email: z.email(),
+  firstName: z.string().nullable().prefault(null),
+  id: z.number().int().positive(),
+  lastName: z.string().nullable().prefault(null),
+  teamId: z.number().int().positive(),
+  workspaceId: z.number().int().positive(),
+})
+
+/** Calendar attendee or diarized speaker attached to a Krisp meeting. */
+export const KRISP_PARTICIPANT_SCHEMA = z.object({
+  email: z.string().nullable().prefault(null),
+  firstName: z.string().nullable().prefault(null),
+  lastName: z.string().nullable().prefault(null),
+  photo: z.url().nullable().prefault(null),
+  status: z.string().nullable().prefault(null),
+})
+
+/** Meeting metadata returned by Krisp list and detail endpoints. */
+export const KRISP_MEETING_SCHEMA = z.object({
+  duration: z.number().int().nonnegative().nullable(),
+  id: z.string().min(1),
+  ownership: z.enum(["owned", "shared"]),
+  participants: KRISP_PARTICIPANT_SCHEMA.array().optional(),
+  source: z.string().nullable(),
+  startedAt: DATE_TIME_SCHEMA.nullable(),
+  status: z.string(),
+  tags: z.string().array(),
+  title: z.string(),
+})
+
+/** One diarized transcript segment. Times are seconds from recording start. */
+export const KRISP_TRANSCRIPT_SEGMENT_SCHEMA = z.object({
+  end: z.number().nonnegative(),
+  speaker: z.number().int().nonnegative(),
+  start: z.number().nonnegative(),
+  text: z.string(),
+})
+
+const KRISP_NOTE_ASSIGNEE_SCHEMA = z.record(z.string(), z.json())
+
+export interface KrispNoteBlock {
+  [key: string]: Encodable
+  assignee?: z.output<typeof KRISP_NOTE_ASSIGNEE_SCHEMA> | null
+  children?: KrispNoteBlock[]
+  completed?: boolean | null
+  dueDate?: string | null
+  text?: string
+  type: string
+}
+
+/** Recursive block returned by Krisp's fixed and custom meeting-note sections. */
+export const KRISP_NOTE_BLOCK_SCHEMA: z.ZodType<KrispNoteBlock> = z.lazy(() =>
+  z.object({
+    assignee: KRISP_NOTE_ASSIGNEE_SCHEMA.nullable().optional(),
+    children: KRISP_NOTE_BLOCK_SCHEMA.array().optional(),
+    completed: z.boolean().nullable().optional(),
+    dueDate: z.string().nullable().optional(),
+    text: z.string().optional(),
+    type: z.string(),
+  }),
+)
+
+/** Complete Krisp meeting detail with optional heavy transcript and note data. */
+export const KRISP_MEETING_DETAIL_SCHEMA = KRISP_MEETING_SCHEMA.extend({
+  language: z.string().nullable().prefault(null),
+  meetingType: z.string().nullable().prefault(null),
+  notes: z
+    .object({ blocks: KRISP_NOTE_BLOCK_SCHEMA.array() })
+    .nullable()
+    .optional(),
+  transcript: z
+    .object({
+      language: z.string().nullable().prefault(null),
+      segments: KRISP_TRANSCRIPT_SEGMENT_SCHEMA.array().prefault([]),
+      speakers: z.record(z.string(), KRISP_PARTICIPANT_SCHEMA).prefault({}),
+    })
+    .nullable()
+    .optional(),
+})
+
+/** One action item extracted from a Krisp meeting. */
+export const KRISP_ACTION_ITEM_SCHEMA = z.object({
+  assignee: KRISP_PARTICIPANT_SCHEMA.nullable().prefault(null),
+  completed: z.boolean().nullable().prefault(null),
+  dueDate: z.string().nullable().prefault(null),
+  id: z.string().min(1),
+  meetingId: z.string().min(1),
+  meetingStartedAt: DATE_TIME_SCHEMA.nullable().prefault(null),
+  meetingTitle: z.string(),
+  title: z.string(),
+})
+
+/** Tag used to organize Krisp meetings. */
+export const KRISP_TAG_SCHEMA = z.object({
+  color: z.string().nullable(),
+  createdAt: DATE_TIME_SCHEMA,
+  id: z.string().min(1),
+  name: z.string(),
+})
+
+/** Recording-import identity returned after Krisp issues an upload URL. */
+export const KRISP_IMPORT_SCHEMA = z.object({
+  expiresAt: DATE_TIME_SCHEMA,
+  importId: z.string().min(1),
+  url: z.url(),
+})
+
+/** Current processing state for a Krisp recording import. */
+export const KRISP_IMPORT_STATUS_SCHEMA = z.object({
+  error: z.string().nullable().prefault(null),
+  importId: z.string().min(1),
+  meetingId: z.string().min(1).nullable().prefault(null),
+  status: z.enum(["uploading", "processing", "ready", "failed"]),
+})

package/src/triggers.ts

@@ -22,6 +22,7 @@ import type { googleAdsTriggerContracts } from "./google-ads"
 import type { googleSheetsTriggerContracts } from "./google-sheets"
 import type { hubspotTriggerContracts } from "./hubspot"
 import type { highLevelTriggerContracts } from "./highlevel"
+import type { kitTriggerContracts } from "./kit"
 import type { linearTriggerContracts } from "./linear"
 import type { millionVerifierTriggerContracts } from "./millionverifier"
 import type { metaAdsTriggerContracts } from "./meta-ads"
@@ -63,6 +64,7 @@ export type TriggerContractMap = typeof airtableTriggerContracts &
   typeof googleSheetsTriggerContracts &
   typeof hubspotTriggerContracts &
   typeof highLevelTriggerContracts &
+  typeof kitTriggerContracts &
   typeof linearTriggerContracts &
   typeof millionVerifierTriggerContracts &
   typeof metaAdsTriggerContracts &