@tailor-platform/sdk 1.17.1 → 1.19.0

package/dist/{job-CULA2Pvf.mjs → job-2Q82qQ6N.mjs}

@@ -1,3 +1,16 @@
+import { t as brandValue } from "./brand-BZJCv6UY.mjs";
+
+//#region src/configure/types/user.ts
+/** Represents an unauthenticated user in the Tailor platform. */
+const unauthenticatedTailorUser = {
+	id: "00000000-0000-0000-0000-000000000000",
+	type: "",
+	workspaceId: "00000000-0000-0000-0000-000000000000",
+	attributes: null,
+	attributeList: []
+};
+
+//#endregion
 //#region src/configure/services/workflow/job.ts
 /**
 * Environment variable key for workflow testing.
@@ -5,6 +18,11 @@
 */
 const WORKFLOW_TEST_ENV_KEY = "TAILOR_TEST_WORKFLOW_ENV";
 /**
+* Environment variable key for workflow user testing.
+* Contains JSON-serialized TailorUser object.
+*/
+const WORKFLOW_TEST_USER_KEY = "TAILOR_TEST_WORKFLOW_USER";
+/**
 * Create a workflow job definition.
 *
 * All jobs must be named exports from the workflow file.
@@ -35,17 +53,21 @@ const WORKFLOW_TEST_ENV_KEY = "TAILOR_TEST_WORKFLOW_ENV";
 * });
 */
 const createWorkflowJob = (config) => {
-	return {
+	return brandValue({
 		name: config.name,
 		trigger: async (args) => {
 			const env = JSON.parse(process.env[WORKFLOW_TEST_ENV_KEY] || "{}");
-			const result = await config.body(args, { env });
+			const user = process.env[WORKFLOW_TEST_USER_KEY] ? JSON.parse(process.env[WORKFLOW_TEST_USER_KEY]) : unauthenticatedTailorUser;
+			const result = await config.body(args, {
+				env,
+				user
+			});
 			return result ? JSON.parse(JSON.stringify(result)) : result;
 		},
 		body: config.body
-	};
+	});
 };
 
 //#endregion
-export { createWorkflowJob as n, WORKFLOW_TEST_ENV_KEY as t };
-//# sourceMappingURL=job-CULA2Pvf.mjs.map
+export { unauthenticatedTailorUser as i, WORKFLOW_TEST_USER_KEY as n, createWorkflowJob as r, WORKFLOW_TEST_ENV_KEY as t };
+//# sourceMappingURL=job-2Q82qQ6N.mjs.map

package/dist/job-2Q82qQ6N.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-2Q82qQ6N.mjs","names":[],"sources":["../src/configure/types/user.ts","../src/configure/services/workflow/job.ts"],"sourcesContent":["// Interfaces for module augmentation\n// Users can extend these via: declare module \"@tailor-platform/sdk\" { interface AttributeMap { ... } }\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface AttributeMap {}\nexport interface AttributeList {\n  __tuple?: []; // Marker for tuple type\n}\n\nexport type InferredAttributeMap = keyof AttributeMap extends never\n  ? Record<string, string | string[] | boolean | boolean[] | undefined>\n  : AttributeMap;\n\nexport type InferredAttributeList = AttributeList[\"__tuple\"] extends []\n  ? string[]\n  : AttributeList[\"__tuple\"];\n\n/** Represents a user in the Tailor platform. */\nexport type TailorUser = {\n  /**\n   * The ID of the user.\n   * For unauthenticated users, this will be a nil UUID.\n   */\n  id: string;\n  /**\n   * The type of the user.\n   * For unauthenticated users, this will be an empty string.\n   */\n  type: \"user\" | \"machine_user\" | \"\";\n  /** The ID of the workspace the user belongs to. */\n  workspaceId: string;\n  /**\n   * A map of the user's attributes.\n   * For unauthenticated users, this will be null.\n   */\n  attributes: InferredAttributeMap | null;\n  /**\n   * A list of the user's attributes.\n   * For unauthenticated users, this will be an empty array.\n   */\n  attributeList: InferredAttributeList;\n};\n\n/** Represents an unauthenticated user in the Tailor platform. */\nexport const unauthenticatedTailorUser: TailorUser = {\n  id: \"00000000-0000-0000-0000-000000000000\",\n  type: \"\",\n  workspaceId: \"00000000-0000-0000-0000-000000000000\",\n  attributes: null,\n  attributeList: [],\n};\n","import { unauthenticatedTailorUser } from \"@/configure/types/user\";\nimport { brandValue } from \"@/utils/brand\";\nimport type { TailorEnv } from \"@/configure/types/env\";\nimport type { JsonCompatible } from \"@/configure/types/helpers\";\nimport type { TailorUser } from \"@/configure/types/user\";\nimport type { Jsonifiable, Jsonify, JsonPrimitive } from \"type-fest\";\n\n/**\n * Context object passed as the second argument to workflow job body functions.\n */\nexport type WorkflowJobContext = {\n  env: TailorEnv;\n  user: TailorUser;\n};\n\n/**\n * Allowed output types for workflow job body functions.\n * Includes Jsonifiable (JSON-serializable values including objects with toJSON like Date),\n * undefined, and void.\n */\nexport type WorkflowJobOutput = Jsonifiable | undefined | void;\n\n/**\n * Convert output type to what trigger returns after JSON serialization.\n * - Jsonifiable values are converted via Jsonify (Date -> string, etc.)\n * - undefined remains undefined\n * - void becomes void\n */\ntype JsonifyOutput<T> = T extends Jsonifiable ? Jsonify<T> : T;\n\n/**\n * Input type constraint for workflow jobs.\n * Accepts any type that is JSON-compatible (primitives, arrays, objects with JSON-compatible values).\n * Excludes objects with toJSON method (like Date) since they won't be serialized in input.\n */\nexport type WorkflowJobInput = undefined | JsonCompatible<unknown>;\n\n/**\n * WorkflowJob represents a job that can be triggered in a workflow.\n *\n * Type constraints:\n * - Input: Must be JSON-compatible (no Date/toJSON objects) or undefined. Interfaces are allowed.\n * - Output: Must be Jsonifiable, undefined, or void\n * - Trigger returns Jsonify<Output> (Date becomes string after JSON.stringify)\n */\nexport interface WorkflowJob<Name extends string = string, Input = undefined, Output = undefined> {\n  name: Name;\n  /**\n   * Trigger this job with the given input.\n   * At runtime, this is a placeholder that calls the body function.\n   * During bundling, calls to .trigger() are transformed to\n   * tailor.workflow.triggerJobFunction(\"<job-name>\", args).\n   *\n   * Returns Jsonify<Output> because the value passes through JSON.stringify.\n   *\n   * Inside a workflow job body, .trigger() calls are transformed by the bundler\n   * into synchronous `triggerJobFunction` calls. You may use `await` for\n   * readability — the bundler strips it automatically at build time.\n   * @example\n   * // Both styles work — await is stripped by the bundler:\n   * body: async (input) => {\n   *   const a = await jobA.trigger({ id: input.id });\n   *   const b = await jobB.trigger({ id: input.id });\n   *   return { a, b };\n   * }\n   */\n  trigger: [Input] extends [undefined]\n    ? () => Promise<JsonifyOutput<Awaited<Output>>>\n    : (input: Input) => Promise<JsonifyOutput<Awaited<Output>>>;\n  body: (input: Input, context: WorkflowJobContext) => Output | Promise<Output>;\n}\n\n/**\n * Helper type to check if all property types are valid.\n * Uses -? to remove optional modifiers so all properties are treated uniformly.\n */\ntype AllPropertiesValid<T> = {\n  [K in keyof T]-?: IsValidInput<T[K]> extends true ? true : false;\n}[keyof T] extends true\n  ? true\n  : false;\n\n/**\n * Check if a type contains any non-JSON-compatible values.\n * Returns `true` if the type is valid for input, `false` otherwise.\n *\n * Accepts:\n * - JSON primitives (string, number, boolean, null)\n * - undefined\n * - Optional primitives (e.g., string | undefined)\n * - Arrays of valid types\n * - Objects with valid field types\n *\n * Rejects:\n * - Objects with toJSON methods (like Date)\n * - Other non-JSON-serializable types\n */\ntype IsValidInput<T> = T extends undefined\n  ? true\n  : T extends JsonPrimitive\n    ? true\n    : T extends readonly (infer U)[]\n      ? IsValidInput<U>\n      : T extends object\n        ? T extends { toJSON: () => unknown }\n          ? false\n          : AllPropertiesValid<T>\n        : false;\n\n/**\n * Helper type to check if all property types are valid for output.\n * Uses -? to remove optional modifiers so all properties are treated uniformly.\n */\ntype AllPropertiesValidOutput<T> = {\n  [K in keyof T]-?: IsValidOutput<T[K]> extends true ? true : false;\n}[keyof T] extends true\n  ? true\n  : false;\n\n/**\n * Check if a type is valid for output.\n * Returns `true` if the type is valid, `false` otherwise.\n *\n * Accepts:\n * - JSON primitives (string, number, boolean, null)\n * - undefined and void\n * - Optional primitives (e.g., string | undefined)\n * - Jsonifiable types (Date, objects with toJSON)\n * - Arrays of valid types\n * - Objects with valid field types\n */\ntype IsValidOutput<T> = T extends undefined | void\n  ? true\n  : T extends JsonPrimitive\n    ? true\n    : T extends readonly (infer U)[]\n      ? IsValidOutput<U>\n      : T extends object\n        ? AllPropertiesValidOutput<T>\n        : false;\n\n/**\n * Body function type with conditional constraint.\n * If input contains invalid types (like Date), the body type becomes `never` to cause an error.\n */\ntype WorkflowJobBody<I, O> =\n  IsValidInput<I> extends true\n    ? IsValidOutput<O> extends true\n      ? (input: I, context: WorkflowJobContext) => O | Promise<O>\n      : never\n    : never;\n\n/**\n * Environment variable key for workflow testing.\n * Contains JSON-serialized TailorEnv object.\n */\nexport const WORKFLOW_TEST_ENV_KEY = \"TAILOR_TEST_WORKFLOW_ENV\";\n\n/**\n * Environment variable key for workflow user testing.\n * Contains JSON-serialized TailorUser object.\n */\nexport const WORKFLOW_TEST_USER_KEY = \"TAILOR_TEST_WORKFLOW_USER\";\n\n/**\n * Create a workflow job definition.\n *\n * All jobs must be named exports from the workflow file.\n * Job names must be unique across the entire project.\n * @param config - Job configuration with name and body function\n * @param config.name - Unique job name across the project\n * @param config.body - Async function that processes the job input\n * @returns A WorkflowJob that can be triggered from other jobs\n * @example\n * // Simple job with async body:\n * export const fetchData = createWorkflowJob({\n *   name: \"fetch-data\",\n *   body: async (input: { id: string }) => {\n *     const db = getDB(\"tailordb\");\n *     return await db.selectFrom(\"Table\").selectAll().where(\"id\", \"=\", input.id).executeTakeFirst();\n *   },\n * });\n * @example\n * // Orchestrator job that fans out to other jobs.\n * // await is optional — the bundler strips it at build time.\n * export const orchestrate = createWorkflowJob({\n *   name: \"orchestrate\",\n *   body: async (input: { orderId: string }) => {\n *     const inventory = await checkInventory.trigger({ orderId: input.orderId });\n *     const payment = await processPayment.trigger({ orderId: input.orderId });\n *     return { inventory, payment };\n *   },\n * });\n */\nexport const createWorkflowJob = <const Name extends string, I = undefined, O = undefined>(config: {\n  readonly name: Name;\n  readonly body: WorkflowJobBody<I, O>;\n}): WorkflowJob<Name, I, Awaited<O>> => {\n  return brandValue({\n    name: config.name,\n    // JSON.parse(JSON.stringify(...)) ensures the return value matches Jsonify<Output> type.\n    // This converts Date objects to strings, matching actual runtime behavior.\n    // In production, bundler transforms .trigger() calls to tailor.workflow.triggerJobFunction().\n    trigger: async (args?: unknown) => {\n      const env: TailorEnv = JSON.parse(process.env[WORKFLOW_TEST_ENV_KEY] || \"{}\");\n      const user: TailorUser = process.env[WORKFLOW_TEST_USER_KEY]\n        ? JSON.parse(process.env[WORKFLOW_TEST_USER_KEY])\n        : unauthenticatedTailorUser;\n      const result = await config.body(args as I, { env, user });\n      return result ? JSON.parse(JSON.stringify(result)) : result;\n    },\n    body: config.body,\n  } as WorkflowJob<Name, I, Awaited<O>>);\n};\n"],"mappings":";;;;AA2CA,MAAa,4BAAwC;CACnD,IAAI;CACJ,MAAM;CACN,aAAa;CACb,YAAY;CACZ,eAAe,EAAE;CAClB;;;;;;;;AC2GD,MAAa,wBAAwB;;;;;AAMrC,MAAa,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtC,MAAa,qBAA8E,WAGnD;AACtC,QAAO,WAAW;EAChB,MAAM,OAAO;EAIb,SAAS,OAAO,SAAmB;GACjC,MAAM,MAAiB,KAAK,MAAM,QAAQ,IAAI,0BAA0B,KAAK;GAC7E,MAAM,OAAmB,QAAQ,IAAI,0BACjC,KAAK,MAAM,QAAQ,IAAI,wBAAwB,GAC/C;GACJ,MAAM,SAAS,MAAM,OAAO,KAAK,MAAW;IAAE;IAAK;IAAM,CAAC;AAC1D,UAAO,SAAS,KAAK,MAAM,KAAK,UAAU,OAAO,CAAC,GAAG;;EAEvD,MAAM,OAAO;EACd,CAAqC"}

package/dist/kysely-type-Cpq5TNGY.mjs

@@ -0,0 +1,260 @@
+import ml from "multiline-ts";
+
+//#region src/plugin/builtin/kysely-type/type-processor.ts
+/**
+* Get the enum type definition.
+* @param fieldConfig - The field configuration
+* @returns The enum type as a string union
+*/
+function getEnumType(fieldConfig) {
+	const allowedValues = fieldConfig.allowedValues;
+	if (allowedValues && Array.isArray(allowedValues)) return allowedValues.map((v) => {
+		return `"${typeof v === "string" ? v : v.value}"`;
+	}).join(" | ");
+	return "string";
+}
+/**
+* Get the nested object type definition.
+* @param fieldConfig - The field configuration
+* @returns The nested type with used utility types
+*/
+function getNestedType(fieldConfig) {
+	const fields = fieldConfig.fields;
+	if (!fields || typeof fields !== "object") return {
+		type: "string",
+		usedUtilityTypes: {
+			Timestamp: false,
+			Serial: false
+		}
+	};
+	const fieldResults = Object.entries(fields).map(([fieldName, nestedOperatorFieldConfig]) => ({
+		fieldName,
+		...generateFieldType(nestedOperatorFieldConfig)
+	}));
+	const fieldTypes = fieldResults.map((result) => `${result.fieldName}: ${result.type}`);
+	const aggregatedUtilityTypes = fieldResults.reduce((acc, result) => ({
+		Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,
+		Serial: acc.Serial || result.usedUtilityTypes.Serial
+	}), {
+		Timestamp: false,
+		Serial: false
+	});
+	return {
+		type: `{\n  ${fieldTypes.join(";\n  ")}${fieldTypes.length > 0 ? ";" : ""}\n}`,
+		usedUtilityTypes: aggregatedUtilityTypes
+	};
+}
+/**
+* Get the base Kysely type for a field (without array/null modifiers).
+* @param fieldConfig - The field configuration
+* @returns The base type with used utility types
+*/
+function getBaseType(fieldConfig) {
+	const fieldType = fieldConfig.type;
+	const usedUtilityTypes = {
+		Timestamp: false,
+		Serial: false
+	};
+	let type;
+	switch (fieldType) {
+		case "uuid":
+		case "string":
+		case "decimal":
+			type = "string";
+			break;
+		case "integer":
+		case "float":
+			type = "number";
+			break;
+		case "date":
+		case "datetime":
+			usedUtilityTypes.Timestamp = true;
+			type = "Timestamp";
+			break;
+		case "bool":
+		case "boolean":
+			type = "boolean";
+			break;
+		case "enum":
+			type = getEnumType(fieldConfig);
+			break;
+		case "nested": return getNestedType(fieldConfig);
+		default:
+			type = "string";
+			break;
+	}
+	return {
+		type,
+		usedUtilityTypes
+	};
+}
+/**
+* Generate the complete field type including array and null modifiers.
+* @param fieldConfig - The field configuration
+* @returns The complete field type with used utility types
+*/
+function generateFieldType(fieldConfig) {
+	const baseTypeResult = getBaseType(fieldConfig);
+	const usedUtilityTypes = { ...baseTypeResult.usedUtilityTypes };
+	const isArray = fieldConfig.array === true;
+	const isNullable = fieldConfig.required !== true;
+	let finalType = baseTypeResult.type;
+	if (isArray) finalType = fieldConfig.type === "enum" ? `(${baseTypeResult.type})[]` : `${baseTypeResult.type}[]`;
+	if (isNullable) finalType = `${finalType} | null`;
+	if (fieldConfig.serial) {
+		usedUtilityTypes.Serial = true;
+		finalType = `Serial<${finalType}>`;
+	}
+	if (fieldConfig.hooks?.create) finalType = `Generated<${finalType}>`;
+	return {
+		type: finalType,
+		usedUtilityTypes
+	};
+}
+/**
+* Generate the table interface.
+* @param type - The parsed TailorDB type
+* @returns The type definition and used utility types
+*/
+function generateTableInterface(type) {
+	const fieldResults = Object.entries(type.fields).filter(([fieldName]) => fieldName !== "id").map(([fieldName, parsedField]) => ({
+		fieldName,
+		...generateFieldType(parsedField.config)
+	}));
+	const fields = ["id: Generated<string>;", ...fieldResults.map((result) => `${result.fieldName}: ${result.type};`)];
+	const aggregatedUtilityTypes = fieldResults.reduce((acc, result) => ({
+		Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,
+		Serial: acc.Serial || result.usedUtilityTypes.Serial
+	}), {
+		Timestamp: false,
+		Serial: false
+	});
+	return {
+		typeDef: ml`
+    ${type.name}: {
+      ${fields.join("\n")}
+    }
+  `,
+		usedUtilityTypes: aggregatedUtilityTypes
+	};
+}
+/**
+* Convert a TailorDBType into KyselyTypeMetadata.
+* @param type - Parsed TailorDB type
+* @returns Generated Kysely type metadata
+*/
+async function processKyselyType(type) {
+	const result = generateTableInterface(type);
+	return {
+		name: type.name,
+		typeDef: result.typeDef,
+		usedUtilityTypes: result.usedUtilityTypes
+	};
+}
+/**
+* Generate unified types file from multiple namespaces.
+* @param namespaceData - Namespace metadata
+* @returns Generated types file contents
+*/
+function generateUnifiedKyselyTypes(namespaceData) {
+	if (namespaceData.length === 0) return "";
+	const globalUsedUtilityTypes = namespaceData.reduce((acc, ns) => ({
+		Timestamp: acc.Timestamp || ns.usedUtilityTypes.Timestamp,
+		Serial: acc.Serial || ns.usedUtilityTypes.Serial
+	}), {
+		Timestamp: false,
+		Serial: false
+	});
+	const utilityTypeImports = ["type Generated"];
+	if (globalUsedUtilityTypes.Timestamp) utilityTypeImports.push("type Timestamp");
+	if (globalUsedUtilityTypes.Serial) utilityTypeImports.push("type Serial");
+	return [
+		ml`
+    import {
+      createGetDB,
+      ${utilityTypeImports.join(",\n")},
+      type NamespaceDB,
+      type NamespaceInsertable,
+      type NamespaceSelectable,
+      type NamespaceTable,
+      type NamespaceTableName,
+      type NamespaceTransaction,
+      type NamespaceUpdateable,
+    } from "@tailor-platform/sdk/kysely";
+  `,
+		`export interface Namespace {\n${namespaceData.map(({ namespace, types }) => {
+			return `  "${namespace}": {\n${types.map((type) => {
+				return type.typeDef.split("\n").map((line) => line.trim() ? `    ${line}` : "").join("\n");
+			}).join("\n\n")}\n  }`;
+		}).join(",\n")}\n}`,
+		ml`
+    export const getDB = createGetDB<Namespace>();
+
+    export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
+  `,
+		ml`
+    export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
+      NamespaceTransaction<Namespace, K>;
+
+    type TableName = NamespaceTableName<Namespace>;
+    export type Table<T extends TableName> = NamespaceTable<Namespace, T>;
+
+    export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;
+    export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;
+    export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;
+  `
+	].join("\n\n") + "\n";
+}
+
+//#endregion
+//#region src/plugin/builtin/kysely-type/index.ts
+const KyselyGeneratorID = "@tailor-platform/kysely-type";
+/**
+* Plugin that generates Kysely type definitions for TailorDB types.
+* @param options - Plugin options
+* @param options.distPath - Output file path for generated types
+* @returns Plugin instance with onTailorDBReady hook
+*/
+function kyselyTypePlugin(options) {
+	return {
+		id: KyselyGeneratorID,
+		description: "Generates Kysely type definitions for TailorDB types",
+		pluginConfig: options,
+		async onTailorDBReady(ctx) {
+			const allNamespaceData = [];
+			for (const ns of ctx.tailordb) {
+				const typeMetadataList = [];
+				for (const type of Object.values(ns.types)) {
+					const metadata = await processKyselyType(type);
+					typeMetadataList.push(metadata);
+				}
+				if (typeMetadataList.length === 0) continue;
+				const usedUtilityTypes = typeMetadataList.reduce((acc, type) => ({
+					Timestamp: acc.Timestamp || type.usedUtilityTypes.Timestamp,
+					Serial: acc.Serial || type.usedUtilityTypes.Serial
+				}), {
+					Timestamp: false,
+					Serial: false
+				});
+				allNamespaceData.push({
+					namespace: ns.namespace,
+					types: typeMetadataList,
+					usedUtilityTypes
+				});
+			}
+			const files = [];
+			if (allNamespaceData.length > 0) {
+				const content = generateUnifiedKyselyTypes(allNamespaceData);
+				files.push({
+					path: ctx.pluginConfig.distPath,
+					content
+				});
+			}
+			return { files };
+		}
+	};
+}
+
+//#endregion
+export { kyselyTypePlugin as n, KyselyGeneratorID as t };
+//# sourceMappingURL=kysely-type-Cpq5TNGY.mjs.map

package/dist/kysely-type-Cpq5TNGY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-type-Cpq5TNGY.mjs","names":[],"sources":["../src/plugin/builtin/kysely-type/type-processor.ts","../src/plugin/builtin/kysely-type/index.ts"],"sourcesContent":["import multiline from \"multiline-ts\";\nimport { type KyselyNamespaceMetadata, type KyselyTypeMetadata } from \"./types\";\nimport type { OperatorFieldConfig, TailorDBType } from \"@/parser/service/tailordb/types\";\n\ntype UsedUtilityTypes = { Timestamp: boolean; Serial: boolean };\n\ntype FieldTypeResult = {\n  type: string;\n  usedUtilityTypes: UsedUtilityTypes;\n};\n\n/**\n * Get the enum type definition.\n * @param fieldConfig - The field configuration\n * @returns The enum type as a string union\n */\nfunction getEnumType(fieldConfig: OperatorFieldConfig): string {\n  const allowedValues = fieldConfig.allowedValues;\n\n  if (allowedValues && Array.isArray(allowedValues)) {\n    return allowedValues\n      .map((v: string | { value: string }) => {\n        const value = typeof v === \"string\" ? v : v.value;\n        return `\"${value}\"`;\n      })\n      .join(\" | \");\n  }\n  return \"string\";\n}\n\n/**\n * Get the nested object type definition.\n * @param fieldConfig - The field configuration\n * @returns The nested type with used utility types\n */\nfunction getNestedType(fieldConfig: OperatorFieldConfig): FieldTypeResult {\n  const fields = fieldConfig.fields;\n  if (!fields || typeof fields !== \"object\") {\n    return {\n      type: \"string\",\n      usedUtilityTypes: { Timestamp: false, Serial: false },\n    };\n  }\n\n  const fieldResults = Object.entries(fields).map(([fieldName, nestedOperatorFieldConfig]) => ({\n    fieldName,\n    ...generateFieldType(nestedOperatorFieldConfig),\n  }));\n\n  const fieldTypes = fieldResults.map((result) => `${result.fieldName}: ${result.type}`);\n\n  const aggregatedUtilityTypes = fieldResults.reduce(\n    (acc, result) => ({\n      Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,\n      Serial: acc.Serial || result.usedUtilityTypes.Serial,\n    }),\n    { Timestamp: false, Serial: false },\n  );\n\n  const type = `{\\n  ${fieldTypes.join(\";\\n  \")}${fieldTypes.length > 0 ? \";\" : \"\"}\\n}`;\n  return { type, usedUtilityTypes: aggregatedUtilityTypes };\n}\n\n/**\n * Get the base Kysely type for a field (without array/null modifiers).\n * @param fieldConfig - The field configuration\n * @returns The base type with used utility types\n */\nfunction getBaseType(fieldConfig: OperatorFieldConfig): FieldTypeResult {\n  const fieldType = fieldConfig.type;\n  const usedUtilityTypes = { Timestamp: false, Serial: false };\n\n  let type: string;\n  switch (fieldType) {\n    case \"uuid\":\n    case \"string\":\n    case \"decimal\":\n      type = \"string\";\n      break;\n    case \"integer\":\n    case \"float\":\n      type = \"number\";\n      break;\n    case \"date\":\n    case \"datetime\":\n      usedUtilityTypes.Timestamp = true;\n      type = \"Timestamp\";\n      break;\n    case \"bool\":\n    case \"boolean\":\n      type = \"boolean\";\n      break;\n    case \"enum\":\n      type = getEnumType(fieldConfig);\n      break;\n    case \"nested\": {\n      const nestedResult = getNestedType(fieldConfig);\n      return nestedResult;\n    }\n    default:\n      type = \"string\";\n      break;\n  }\n\n  return { type, usedUtilityTypes };\n}\n\n/**\n * Generate the complete field type including array and null modifiers.\n * @param fieldConfig - The field configuration\n * @returns The complete field type with used utility types\n */\nfunction generateFieldType(fieldConfig: OperatorFieldConfig): FieldTypeResult {\n  const baseTypeResult = getBaseType(fieldConfig);\n  const usedUtilityTypes = { ...baseTypeResult.usedUtilityTypes };\n\n  const isArray = fieldConfig.array === true;\n  const isNullable = fieldConfig.required !== true;\n\n  let finalType = baseTypeResult.type;\n  if (isArray) {\n    // Wrap enum types in parentheses before adding array suffix\n    const needsParens = fieldConfig.type === \"enum\";\n    finalType = needsParens ? `(${baseTypeResult.type})[]` : `${baseTypeResult.type}[]`;\n  }\n  if (isNullable) {\n    finalType = `${finalType} | null`;\n  }\n\n  if (fieldConfig.serial) {\n    usedUtilityTypes.Serial = true;\n    finalType = `Serial<${finalType}>`;\n  }\n  if (fieldConfig.hooks?.create) {\n    finalType = `Generated<${finalType}>`;\n  }\n\n  return { type: finalType, usedUtilityTypes };\n}\n\n/**\n * Generate the table interface.\n * @param type - The parsed TailorDB type\n * @returns The type definition and used utility types\n */\nfunction generateTableInterface(type: TailorDBType): {\n  typeDef: string;\n  usedUtilityTypes: UsedUtilityTypes;\n} {\n  const fieldEntries = Object.entries(type.fields).filter(([fieldName]) => fieldName !== \"id\");\n\n  const fieldResults = fieldEntries.map(([fieldName, parsedField]) => ({\n    fieldName,\n    ...generateFieldType(parsedField.config),\n  }));\n\n  const fields = [\n    \"id: Generated<string>;\",\n    ...fieldResults.map((result) => `${result.fieldName}: ${result.type};`),\n  ];\n\n  const aggregatedUtilityTypes = fieldResults.reduce(\n    (acc, result) => ({\n      Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,\n      Serial: acc.Serial || result.usedUtilityTypes.Serial,\n    }),\n    { Timestamp: false, Serial: false },\n  );\n\n  const typeDef = multiline /* ts */ `\n    ${type.name}: {\n      ${fields.join(\"\\n\")}\n    }\n  `;\n\n  return { typeDef, usedUtilityTypes: aggregatedUtilityTypes };\n}\n\n/**\n * Convert a TailorDBType into KyselyTypeMetadata.\n * @param type - Parsed TailorDB type\n * @returns Generated Kysely type metadata\n */\nexport async function processKyselyType(type: TailorDBType): Promise<KyselyTypeMetadata> {\n  const result = generateTableInterface(type);\n\n  return {\n    name: type.name,\n    typeDef: result.typeDef,\n    usedUtilityTypes: result.usedUtilityTypes,\n  };\n}\n\n/**\n * Generate unified types file from multiple namespaces.\n * @param namespaceData - Namespace metadata\n * @returns Generated types file contents\n */\nexport function generateUnifiedKyselyTypes(namespaceData: KyselyNamespaceMetadata[]): string {\n  if (namespaceData.length === 0) {\n    return \"\";\n  }\n\n  // Aggregate used utility types from all namespaces\n  const globalUsedUtilityTypes = namespaceData.reduce(\n    (acc, ns) => ({\n      Timestamp: acc.Timestamp || ns.usedUtilityTypes.Timestamp,\n      Serial: acc.Serial || ns.usedUtilityTypes.Serial,\n    }),\n    { Timestamp: false, Serial: false },\n  );\n\n  const utilityTypeImports: string[] = [\"type Generated\"];\n  if (globalUsedUtilityTypes.Timestamp) {\n    utilityTypeImports.push(\"type Timestamp\");\n  }\n  if (globalUsedUtilityTypes.Serial) {\n    utilityTypeImports.push(\"type Serial\");\n  }\n\n  const importsSection = multiline /* ts */ `\n    import {\n      createGetDB,\n      ${utilityTypeImports.join(\",\\n\")},\n      type NamespaceDB,\n      type NamespaceInsertable,\n      type NamespaceSelectable,\n      type NamespaceTable,\n      type NamespaceTableName,\n      type NamespaceTransaction,\n      type NamespaceUpdateable,\n    } from \"@tailor-platform/sdk/kysely\";\n  `;\n\n  // Generate Namespace interface with multiple namespaces\n  const namespaceInterfaces = namespaceData\n    .map(({ namespace, types }) => {\n      const typeDefsWithIndent = types\n        .map((type) => {\n          return type.typeDef\n            .split(\"\\n\")\n            .map((line) => (line.trim() ? `    ${line}` : \"\"))\n            .join(\"\\n\");\n        })\n        .join(\"\\n\\n\");\n\n      return `  \"${namespace}\": {\\n${typeDefsWithIndent}\\n  }`;\n    })\n    .join(\",\\n\");\n\n  const namespaceInterface = `export interface Namespace {\\n${namespaceInterfaces}\\n}`;\n\n  const getDBFunction = multiline /* ts */ `\n    export const getDB = createGetDB<Namespace>();\n\n    export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;\n  `;\n\n  const utilityTypeExports = multiline /* ts */ `\n    export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =\n      NamespaceTransaction<Namespace, K>;\n\n    type TableName = NamespaceTableName<Namespace>;\n    export type Table<T extends TableName> = NamespaceTable<Namespace, T>;\n\n    export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;\n    export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;\n    export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;\n  `;\n\n  return (\n    [importsSection, namespaceInterface, getDBFunction, utilityTypeExports].join(\"\\n\\n\") + \"\\n\"\n  );\n}\n","import { processKyselyType, generateUnifiedKyselyTypes } from \"./type-processor\";\nimport type { KyselyTypeMetadata, KyselyNamespaceMetadata } from \"./types\";\nimport type {\n  GeneratorResult,\n  TailorDBReadyContext,\n} from \"@/parser/plugin-config/generation-types\";\nimport type { Plugin } from \"@/parser/plugin-config/types\";\n\nexport const KyselyGeneratorID = \"@tailor-platform/kysely-type\";\n\ntype KyselyTypePluginOptions = {\n  distPath: string;\n};\n\n/**\n * Plugin that generates Kysely type definitions for TailorDB types.\n * @param options - Plugin options\n * @param options.distPath - Output file path for generated types\n * @returns Plugin instance with onTailorDBReady hook\n */\nexport function kyselyTypePlugin(\n  options: KyselyTypePluginOptions,\n): Plugin<unknown, KyselyTypePluginOptions> {\n  return {\n    id: KyselyGeneratorID,\n    description: \"Generates Kysely type definitions for TailorDB types\",\n    pluginConfig: options,\n\n    async onTailorDBReady(\n      ctx: TailorDBReadyContext<KyselyTypePluginOptions>,\n    ): Promise<GeneratorResult> {\n      const allNamespaceData: KyselyNamespaceMetadata[] = [];\n\n      for (const ns of ctx.tailordb) {\n        const typeMetadataList: KyselyTypeMetadata[] = [];\n\n        for (const type of Object.values(ns.types)) {\n          const metadata = await processKyselyType(type);\n          typeMetadataList.push(metadata);\n        }\n\n        if (typeMetadataList.length === 0) continue;\n\n        const usedUtilityTypes = typeMetadataList.reduce(\n          (acc, type) => ({\n            Timestamp: acc.Timestamp || type.usedUtilityTypes.Timestamp,\n            Serial: acc.Serial || type.usedUtilityTypes.Serial,\n          }),\n          { Timestamp: false, Serial: false },\n        );\n\n        allNamespaceData.push({\n          namespace: ns.namespace,\n          types: typeMetadataList,\n          usedUtilityTypes,\n        });\n      }\n\n      const files: GeneratorResult[\"files\"] = [];\n      if (allNamespaceData.length > 0) {\n        const content = generateUnifiedKyselyTypes(allNamespaceData);\n        files.push({\n          path: ctx.pluginConfig.distPath,\n          content,\n        });\n      }\n\n      return { files };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/package-json-DUY2kB6z.mjs

@@ -0,0 +1,17 @@
+import { readPackageJSON } from "pkg-types";
+
+//#region src/cli/utils/package-json.ts
+let packageJson = null;
+/**
+* Read and cache the package.json of the SDK package.
+* @returns Parsed package.json contents
+*/
+async function readPackageJson() {
+	if (packageJson) return packageJson;
+	packageJson = await readPackageJSON(import.meta.url);
+	return packageJson;
+}
+
+//#endregion
+export { readPackageJson as t };
+//# sourceMappingURL=package-json-DUY2kB6z.mjs.map

package/dist/package-json-DUY2kB6z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json-DUY2kB6z.mjs","names":[],"sources":["../src/cli/utils/package-json.ts"],"sourcesContent":["import { readPackageJSON, type PackageJson } from \"pkg-types\";\n\nlet packageJson: PackageJson | null = null;\n\n/**\n * Read and cache the package.json of the SDK package.\n * @returns Parsed package.json contents\n */\nexport async function readPackageJson() {\n  if (packageJson) {\n    return packageJson;\n  }\n  packageJson = await readPackageJSON(import.meta.url);\n  return packageJson;\n}\n"],"mappings":";;;AAEA,IAAI,cAAkC;;;;;AAMtC,eAAsB,kBAAkB;AACtC,KAAI,YACF,QAAO;AAET,eAAc,MAAM,gBAAgB,OAAO,KAAK,IAAI;AACpD,QAAO"}

package/dist/package-json-Dd1AnA5F.mjs

@@ -0,0 +1,3 @@
+import { t as readPackageJson } from "./package-json-DUY2kB6z.mjs";
+
+export { readPackageJson };

package/dist/plugin/builtin/enum-constants/index.d.mts

@@ -0,0 +1,4 @@
+/// <reference path="./../../../user-defined.d.ts" />
+import "../../../types-CblXasFV.mjs";
+import { n as enumConstantsPlugin, t as EnumConstantsGeneratorID } from "../../../index-B91ZpOcd.mjs";
+export { EnumConstantsGeneratorID, enumConstantsPlugin };

package/dist/plugin/builtin/enum-constants/index.mjs

@@ -0,0 +1,3 @@
+import { n as enumConstantsPlugin, t as EnumConstantsGeneratorID } from "../../../enum-constants-CGVvu3dd.mjs";
+
+export { EnumConstantsGeneratorID, enumConstantsPlugin };

package/dist/plugin/builtin/file-utils/index.d.mts

@@ -0,0 +1,4 @@
+/// <reference path="./../../../user-defined.d.ts" />
+import "../../../types-CblXasFV.mjs";
+import { n as fileUtilsPlugin, t as FileUtilsGeneratorID } from "../../../index-DDqKNFh4.mjs";
+export { FileUtilsGeneratorID, fileUtilsPlugin };

package/dist/plugin/builtin/file-utils/index.mjs

@@ -0,0 +1,3 @@
+import { n as fileUtilsPlugin, t as FileUtilsGeneratorID } from "../../../file-utils-GX_tGWl4.mjs";
+
+export { FileUtilsGeneratorID, fileUtilsPlugin };

package/dist/plugin/builtin/kysely-type/index.d.mts

@@ -0,0 +1,4 @@
+/// <reference path="./../../../user-defined.d.ts" />
+import "../../../types-CblXasFV.mjs";
+import { n as kyselyTypePlugin, t as KyselyGeneratorID } from "../../../index-CPzbMghQ.mjs";
+export { KyselyGeneratorID, kyselyTypePlugin };

package/dist/plugin/builtin/kysely-type/index.mjs

@@ -0,0 +1,3 @@
+import { n as kyselyTypePlugin, t as KyselyGeneratorID } from "../../../kysely-type-Cpq5TNGY.mjs";
+
+export { KyselyGeneratorID, kyselyTypePlugin };

package/dist/plugin/builtin/seed/index.d.mts

@@ -0,0 +1,4 @@
+/// <reference path="./../../../user-defined.d.ts" />
+import "../../../types-CblXasFV.mjs";
+import { n as seedPlugin, t as SeedGeneratorID } from "../../../index-B6pvy1MK.mjs";
+export { SeedGeneratorID, seedPlugin };

package/dist/plugin/builtin/seed/index.mjs

@@ -0,0 +1,3 @@
+import { n as seedPlugin, t as SeedGeneratorID } from "../../../seed-CeUEANfQ.mjs";
+
+export { SeedGeneratorID, seedPlugin };

package/dist/plugin/index.d.mts

@@ -1,5 +1,5 @@
 /// <reference path="./../user-defined.d.ts" />
-import { k as TailorAnyDBType, vt as TailorEnv, yt as TailorActor } from "../types-CZZBCaxB.mjs";
+import { Bt as TailorActor, i as TailorAnyDBType, zt as TailorEnv } from "../types-CblXasFV.mjs";
 
 //#region src/plugin/with-context.d.ts
 
@@ -104,8 +104,8 @@ declare function withPluginContext<Ctx>(factory: PluginExecutorFactory<Ctx>): Pl
 //#region src/plugin/get-generated-type.d.ts
 /**
  * Get a generated type from a plugin by loading the config and resolving everything automatically.
- * For type-attached plugins, calls processType() with the sourceType.
- * For namespace plugins, calls processNamespace() with auto-resolved namespace.
+ * For type-attached plugins, calls onTypeLoaded() with the sourceType.
+ * For namespace plugins, calls onNamespaceLoaded() with auto-resolved namespace.
  * Results are cached per config path, plugin, namespace, and pluginConfig to avoid redundant processing.
  * @param configPath - Path to tailor.config.ts (absolute or relative to cwd)
  * @param pluginId - The plugin's unique identifier

package/dist/plugin/index.mjs

@@ -54,7 +54,7 @@ const configCacheMap = /* @__PURE__ */ new Map();
 * @returns True if value has the shape of Plugin
 */
 function isPlugin(value) {
-	return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.importPath === "string";
+	return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.description === "string";
 }
 /**
 * Load and cache config module from the given path.
@@ -120,7 +120,7 @@ async function resolveNamespaceForType(config, configDir, sourceType) {
 }
 /**
 * Resolve the namespace for a namespace plugin by trying each namespace.
-* Calls processNamespace() for each and returns the first whose output contains the requested kind.
+* Calls onNamespaceLoaded() for each and returns the first whose output contains the requested kind.
 * @param config - App config with db namespace definitions
 * @param config.db - DB namespace definitions
 * @param plugin - Plugin instance
@@ -130,10 +130,10 @@ async function resolveNamespaceForType(config, configDir, sourceType) {
 */
 async function resolveNamespaceForNamespacePlugin(config, plugin, kind, pluginConfig) {
 	if (!config.db) throw new Error(`No db configuration found in config`);
-	if (!plugin.processNamespace) throw new Error(`Plugin "${plugin.id}" does not have a processNamespace() method`);
+	if (!plugin.onNamespaceLoaded) throw new Error(`Plugin "${plugin.id}" does not have a onNamespaceLoaded() method`);
 	for (const namespace of Object.keys(config.db)) {
 		if (config.db[namespace].external) continue;
-		const output = await plugin.processNamespace({
+		const output = await plugin.onNamespaceLoaded({
 			pluginConfig,
 			namespace
 		});
@@ -162,8 +162,8 @@ function getCacheKey(baseKey, pluginConfig) {
 }
 /**
 * Get a generated type from a plugin by loading the config and resolving everything automatically.
-* For type-attached plugins, calls processType() with the sourceType.
-* For namespace plugins, calls processNamespace() with auto-resolved namespace.
+* For type-attached plugins, calls onTypeLoaded() with the sourceType.
+* For namespace plugins, calls onNamespaceLoaded() with auto-resolved namespace.
 * Results are cached per config path, plugin, namespace, and pluginConfig to avoid redundant processing.
 * @param configPath - Path to tailor.config.ts (absolute or relative to cwd)
 * @param pluginId - The plugin's unique identifier
@@ -186,7 +186,7 @@ async function getGeneratedType(configPath, pluginId, sourceType, kind) {
 }
 /**
 * Get a generated type from a type-attached plugin.
-* @param plugin - The plugin instance (must have processType() method)
+* @param plugin - The plugin instance (must have onTypeLoaded() method)
 * @param sourceType - The source TailorDB type
 * @param kind - The generated type kind
 * @param pluginConfig - Plugin-level configuration
@@ -194,7 +194,7 @@ async function getGeneratedType(configPath, pluginId, sourceType, kind) {
 * @returns The generated TailorDB type
 */
 async function getGeneratedTypeForTypeAttachedPlugin(plugin, sourceType, kind, pluginConfig, namespace) {
-	if (!plugin.processType) throw new Error(`Plugin "${plugin.id}" does not have a processType() method`);
+	if (!plugin.onTypeLoaded) throw new Error(`Plugin "${plugin.id}" does not have a onTypeLoaded() method`);
 	let pluginCache = processCache.get(plugin);
 	if (!pluginCache) {
 		pluginCache = /* @__PURE__ */ new Map();
@@ -204,7 +204,7 @@ async function getGeneratedTypeForTypeAttachedPlugin(plugin, sourceType, kind, p
 	let output = pluginCache.get(cacheKey);
 	if (!output) {
 		const typeConfig = sourceType.plugins?.find((p) => p.pluginId === plugin.id)?.config;
-		output = await plugin.processType({
+		output = await plugin.onTypeLoaded({
 			type: sourceType,
 			typeConfig: typeConfig ?? {},
 			pluginConfig,
@@ -221,13 +221,13 @@ async function getGeneratedTypeForTypeAttachedPlugin(plugin, sourceType, kind, p
 * Auto-resolves the namespace by trying each one.
 * @param config - App config with db namespace definitions
 * @param config.db - DB namespace definitions
-* @param plugin - The plugin instance (must have processNamespace() method)
+* @param plugin - The plugin instance (must have onNamespaceLoaded() method)
 * @param kind - The generated type kind
 * @param pluginConfig - Plugin-level configuration
 * @returns The generated TailorDB type
 */
 async function getGeneratedTypeForNamespacePlugin(config, plugin, kind, pluginConfig) {
-	if (!plugin.processNamespace) throw new Error(`Plugin "${plugin.id}" does not have a processNamespace() method`);
+	if (!plugin.onNamespaceLoaded) throw new Error(`Plugin "${plugin.id}" does not have a onNamespaceLoaded() method`);
 	let pluginCache = namespaceProcessCache.get(plugin);
 	if (!pluginCache) {
 		pluginCache = /* @__PURE__ */ new Map();