@tailor-platform/sdk 2.0.0-next.1 → 2.0.0-next.11

package/dist/plugin/with-context.d.mts

@@ -0,0 +1,101 @@
+import { TailorEnv, TailorPrincipal } from "../runtime/types.mjs";
+//#region src/plugin/with-context.d.ts
+/**
+ * Plugin executor factory function type.
+ * Takes context and returns an executor configuration.
+ * Returns unknown since the exact return type depends on createExecutor's generic params.
+ */
+type PluginExecutorFactory<Ctx> = (ctx: Ctx) => unknown;
+/**
+ * Base args for plugin executor function operations.
+ * Provides typed access to runtime context without requiring specific record types.
+ */
+interface PluginFunctionArgs {
+  /** Workspace ID where the executor runs */
+  workspaceId: string;
+  /** Application namespace */
+  appNamespace: string;
+  /** Environment variables */
+  env: TailorEnv;
+  /** Principal that triggered the event, null for system events */
+  actor: TailorPrincipal | null;
+  /** Name of the TailorDB type */
+  typeName: string;
+  /** TailorDB connections by namespace */
+  tailordb: Record<string, unknown>;
+}
+/**
+ * Args for plugin executors triggered on record creation.
+ */
+interface PluginRecordCreatedArgs extends PluginFunctionArgs {
+  /** The newly created record */
+  newRecord: Record<string, unknown>;
+}
+/**
+ * Args for plugin executors triggered on record update.
+ */
+interface PluginRecordUpdatedArgs extends PluginFunctionArgs {
+  /** The record after update */
+  newRecord: Record<string, unknown>;
+  /** The record before update */
+  oldRecord: Record<string, unknown>;
+}
+/**
+ * Args for plugin executors triggered on record deletion.
+ */
+interface PluginRecordDeletedArgs extends PluginFunctionArgs {
+  /** The deleted record */
+  oldRecord: Record<string, unknown>;
+}
+/**
+ * Database schema type for plugins.
+ * Since plugins work with dynamic types, the schema uses Record types.
+ */
+type PluginDBSchema = Record<string, Record<string, unknown>>;
+/**
+ * Base record type for TailorDB records.
+ * All records have an id field.
+ */
+type PluginRecord = {
+  id: string;
+} & Record<string, unknown>;
+/**
+ * Define a plugin executor that receives context at runtime.
+ * This allows executor definitions to be in separate files while
+ * still receiving dynamic values like typeName, generated types, and namespace.
+ * @param factory - Function that takes context and returns executor configuration
+ * @returns The same factory function (for type inference)
+ * @example
+ * ```typescript
+ * // executors/on-create.ts
+ * import { withPluginContext } from "@tailor-platform/sdk/plugin";
+ * import { createExecutor, recordCreatedTrigger } from "@tailor-platform/sdk";
+ * import { getDB } from "@tailor-platform/function-kysely-tailordb";
+ *
+ * interface MyContext {
+ *   sourceType: TailorAnyDBType;
+ *   historyType: TailorAnyDBType;
+ *   namespace: string;
+ * }
+ *
+ * export default withPluginContext<MyContext>((ctx) =>
+ *   createExecutor({
+ *     name: `${ctx.sourceType.name.toLowerCase()}-on-create`,
+ *     trigger: recordCreatedTrigger({ type: ctx.sourceType }),
+ *     operation: {
+ *       kind: "function",
+ *       body: async (args) => {
+ *         const db = getDB(ctx.namespace);
+ *         await db.insertInto(ctx.historyType.name).values({
+ *           recordId: args.newRecord.id,
+ *           // ...
+ *         }).execute();
+ *       },
+ *     },
+ *   })
+ * );
+ * ```
+ */
+declare function withPluginContext<Ctx>(factory: PluginExecutorFactory<Ctx>): PluginExecutorFactory<Ctx>;
+//#endregion
+export { PluginDBSchema, PluginExecutorFactory, PluginFunctionArgs, PluginRecord, PluginRecordCreatedArgs, PluginRecordDeletedArgs, PluginRecordUpdatedArgs, withPluginContext };