@tailor-platform/sdk 2.2.0 → 2.4.0

package/dist/{seed-xqM9WIHP.mjs → seed-Cibjmtry.mjs}

@@ -153,23 +153,7 @@ function generateIdpTruncateScriptCode(idpNamespace) {
 */
 function generateIdpUserSchemaFile(options) {
 	const { usernameField, userTypeName, includeUserProfileFK = true } = options;
-	return multiline`
-    import { t } from "@tailor-platform/sdk";
-    import { defineSchema } from "@tailor-platform/sdk/seed";
-    import { createStandardSchema } from "@tailor-platform/sdk/test";
-
-    const schemaType = t.object({
-      name: t.string(),
-      password: t.string(),
-    });
-
-    // Simple identity hook for _User (no TailorDB backing type)
-    export const hook = <T>(data: unknown) => data as T;
-
-    export const schema = defineSchema(
-      createStandardSchema(schemaType, hook),
-      {
-        ${includeUserProfileFK ? multiline`
+	const schemaBody = includeUserProfileFK ? multiline`
       primaryKey: "name",
       indexes: [
         { name: "_user_name_unique_idx", columns: ["name"], unique: true },
@@ -188,7 +172,24 @@ function generateIdpUserSchemaFile(options) {
       indexes: [
         { name: "_user_name_unique_idx", columns: ["name"], unique: true },
       ],
-    `}
+    `;
+	return multiline`
+    import { t } from "@tailor-platform/sdk";
+    import { defineSchema } from "@tailor-platform/sdk/seed";
+    import { createStandardSchema } from "@tailor-platform/sdk/test";
+
+    const schemaType = t.object({
+      name: t.string(),
+      password: t.string(),
+    });
+
+    // Simple identity hook for _User (no TailorDB backing table)
+    export const hook = <T>(data: unknown) => data as T;
+
+    export const schema = defineSchema(
+      createStandardSchema(schemaType, hook),
+      {
+        ${schemaBody}
       }
     );
 
@@ -198,15 +199,15 @@ function generateIdpUserSchemaFile(options) {
 //#endregion
 //#region src/plugin/builtin/seed/lines-db-processor.ts
 /**
-* Processes TailorDB types to generate lines-db metadata
-* @param type - Parsed TailorDB type
+* Processes TailorDB tables to generate lines-db metadata
+* @param type - Parsed TailorDB table
 * @param source - Source file info
 * @returns Generated lines-db metadata
 */
 function processLinesDb(type, source) {
 	if (isPluginGeneratedType(source)) return processLinesDbForPluginType(type, source);
-	if (!source.filePath) throw new Error(`Missing source info for type ${type.name}`);
-	if (!source.exportName) throw new Error(`Missing export name for type ${type.name}`);
+	if (!source.filePath) throw new Error(`Missing source info for table ${type.name}`);
+	if (!source.exportName) throw new Error(`Missing export name for table ${type.name}`);
 	const { optionalFields, omitFields, indexes, foreignKeys } = extractFieldMetadata(type);
 	return {
 		typeName: type.name,
@@ -220,8 +221,8 @@ function processLinesDb(type, source) {
 }
 /**
 * Process lines-db metadata for plugin-generated types
-* @param type - Parsed TailorDB type
-* @param source - Plugin-generated type source info
+* @param type - Parsed TailorDB table
+* @param source - Plugin-generated table source info
 * @returns Generated lines-db metadata with plugin source
 */
 function processLinesDbForPluginType(type, source) {
@@ -238,8 +239,8 @@ function processLinesDbForPluginType(type, source) {
 	};
 }
 /**
-* Extract field metadata from TailorDB type
-* @param type - Parsed TailorDB type
+* Extract field metadata from TailorDB table
+* @param type - Parsed TailorDB table
 * @returns Field metadata including optional fields, omit fields, indexes, and foreign keys
 */
 function extractFieldMetadata(type) {
@@ -304,30 +305,32 @@ function generateSchemaOptions(foreignKeys, indexes) {
 	].join("\n") : "";
 }
 /**
-* Generates the schema file content for lines-db (for user-defined types with import)
+* Generates the schema file content for lines-db (for user-defined tables with import)
 * @param metadata - lines-db metadata
-* @param importPath - Import path for the TailorDB type
+* @param importPath - Import path for the TailorDB table
 * @returns Schema file contents
 */
 function generateLinesDbSchemaFile(metadata, importPath) {
 	const { exportName, optionalFields, omitFields, foreignKeys, indexes } = metadata;
+	const schemaTypeCode = multiline`
+    const schemaType = t.object({
+      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),
+      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),
+    });
+    `;
+	const schemaOptionsCode = generateSchemaOptions(foreignKeys, indexes);
 	return multiline`
     import { t } from "@tailor-platform/sdk";
     import { defineSchema } from "@tailor-platform/sdk/seed";
     import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
     import { ${exportName} } from "${importPath}";
 
-    ${multiline`
-    const schemaType = t.object({
-      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),
-      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),
-    });
-    `}
+    ${schemaTypeCode}
 
     export const hook = createTailorDBHook(${exportName});
 
     export const schema = defineSchema(
-      createStandardSchema(schemaType, hook, ${exportName}),${generateSchemaOptions(foreignKeys, indexes)}
+      createStandardSchema(schemaType, hook, ${exportName}),${schemaOptionsCode}
     );
 
     `;
@@ -421,7 +424,8 @@ function seedPlugin(options) {
 			const idpUser = ctx.auth ? processIdpUser(ctx.auth) ?? null : null;
 			const idpUserSyncFKs = resolveIdpUserSyncFKs(ctx.pluginConfig.disableIdpUserSync);
 			for (const ns of ctx.tailordb) for (const [typeName, type] of Object.entries(ns.types)) {
-				const linesDb = processLinesDb(type, assertDefined(ns.sourceInfo.get(typeName), `source info missing for type: ${typeName}`));
+				const source = assertDefined(ns.sourceInfo.get(typeName), `source info missing for type: ${typeName}`);
+				const linesDb = processLinesDb(type, source);
 				if (idpUserSyncFKs.emitUserToIdpFK && idpUser && typeName === idpUser.schema.userTypeName) linesDb.foreignKeys.push({
 					column: idpUser.schema.usernameField,
 					references: {
@@ -441,17 +445,19 @@ function seedPlugin(options) {
 						const relativePath = path.relative(path.dirname(schemaOutputPath), linesDb.pluginSource.originalFilePath);
 						originalImportPath = relativePath.replace(/\.ts$/, "").startsWith(".") ? relativePath.replace(/\.ts$/, "") : `./${relativePath.replace(/\.ts$/, "")}`;
 					}
-					const schemaContent = generateLinesDbSchemaFileWithPluginAPI(linesDb, {
+					const params = {
 						configImportPath: path.relative(path.dirname(schemaOutputPath), ctx.configPath),
 						originalImportPath
-					});
+					};
+					const schemaContent = generateLinesDbSchemaFileWithPluginAPI(linesDb, params);
 					files.push({
 						path: schemaOutputPath,
 						content: schemaContent
 					});
 				} else {
 					const relativePath = path.relative(path.dirname(schemaOutputPath), linesDb.importPath);
-					const schemaContent = generateLinesDbSchemaFile(linesDb, relativePath.replace(/\.ts$/, "").startsWith(".") ? relativePath.replace(/\.ts$/, "") : `./${relativePath.replace(/\.ts$/, "")}`);
+					const typeImportPath = relativePath.replace(/\.ts$/, "").startsWith(".") ? relativePath.replace(/\.ts$/, "") : `./${relativePath.replace(/\.ts$/, "")}`;
+					const schemaContent = generateLinesDbSchemaFile(linesDb, typeImportPath);
 					files.push({
 						path: schemaOutputPath,
 						content: schemaContent
@@ -480,4 +486,4 @@ function seedPlugin(options) {
 
 //#endregion
 export { generateIdpTruncateScriptCode as a, generateIdpSeedScriptCode as i, seedPlugin as n, processIdpUser as o, processLinesDb as r, SeedGeneratorID as t };
-//# sourceMappingURL=seed-xqM9WIHP.mjs.map
+//# sourceMappingURL=seed-Cibjmtry.mjs.map

package/dist/seed-Cibjmtry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-Cibjmtry.mjs","names":[],"sources":["../src/plugin/builtin/seed/idp-user-processor.ts","../src/plugin/builtin/seed/lines-db-processor.ts","../src/plugin/builtin/seed/index.ts"],"sourcesContent":["import ml from \"#/utils/multiline\";\nimport type { GeneratorAuthInput } from \"#/plugin/types\";\n\nexport interface IdpUserMetadata {\n  name: \"_User\";\n  dependencies: string[];\n  dataFile: string;\n  idpNamespace: string;\n  schema: {\n    usernameField: string;\n    userTypeName: string;\n  };\n}\n\n/**\n * Processes auth configuration to generate IdP user seed metadata\n * @param auth - Auth configuration from generator\n * @returns IdP user metadata or undefined if not applicable\n */\nexport function processIdpUser(auth: GeneratorAuthInput): IdpUserMetadata | undefined {\n  // Only process if idProvider is BuiltInIdP and userProfile is defined\n  if (auth.idProvider?.kind !== \"BuiltInIdP\" || !auth.userProfile) {\n    return undefined;\n  }\n\n  const { typeName, usernameField } = auth.userProfile;\n\n  return {\n    name: \"_User\",\n    dependencies: [typeName],\n    dataFile: \"data/_User.jsonl\",\n    idpNamespace: auth.idProvider.namespace,\n    schema: {\n      usernameField,\n      userTypeName: typeName,\n    },\n  };\n}\n\n/**\n * Generates the server-side IDP seed script code for testExecScript execution.\n * Uses the global tailor.idp.Client - no bundling required.\n * @param idpNamespace - The IDP namespace name\n * @returns Script code string\n */\nexport function generateIdpSeedScriptCode(idpNamespace: string): string {\n  return ml /* ts */ `\n    export async function main(input) {\n      const client = new tailor.idp.Client({ namespace: \"${idpNamespace}\" });\n      const errors = [];\n      let processed = 0;\n      let created = 0;\n      let updated = 0;\n      let skipped = 0;\n      const upsert = input.upsert === true;\n\n      for (let i = 0; i < input.users.length; i++) {\n        try {\n          if (upsert) {\n            let existing;\n            let lookupError;\n            try {\n              existing = await client.userByName(input.users[i].name);\n            } catch (error) {\n              existing = undefined;\n              lookupError = error instanceof Error ? error.message : String(error);\n            }\n\n            if (existing) {\n              const { name, ...attributes } = input.users[i];\n              if (Object.keys(attributes).length === 0) {\n                skipped++;\n              } else {\n                await client.updateUser({ id: existing.id, ...attributes });\n                updated++;\n              }\n            } else {\n              try {\n                await client.createUser(input.users[i]);\n                created++;\n              } catch (error) {\n                const message = error instanceof Error ? error.message : String(error);\n                throw new Error(\n                  lookupError ? \\`create failed (\\${message}); lookup failed (\\${lookupError})\\` : message,\n                );\n              }\n            }\n          } else {\n            await client.createUser(input.users[i]);\n            created++;\n          }\n          processed++;\n          console.log(\\`[_User] \\${i + 1}/\\${input.users.length}: \\${input.users[i].name}\\`);\n        } catch (error) {\n          const message = error instanceof Error ? error.message : String(error);\n          errors.push(\\`Row \\${i} (\\${input.users[i].name}): \\${message}\\`);\n          console.error(\\`[_User] Row \\${i} failed: \\${message}\\`);\n        }\n      }\n\n      return {\n        success: errors.length === 0,\n        processed,\n        created,\n        updated,\n        skipped,\n        errors,\n      };\n    }\n  `;\n}\n\n/**\n * Generates the server-side IDP truncation script code for testExecScript execution.\n * Lists all users with pagination and deletes each one.\n * @param idpNamespace - The IDP namespace name\n * @returns Script code string\n */\nexport function generateIdpTruncateScriptCode(idpNamespace: string): string {\n  return ml /* ts */ `\n    export async function main() {\n      const client = new tailor.idp.Client({ namespace: \"${idpNamespace}\" });\n      const errors = [];\n      let deleted = 0;\n\n      // List all users with pagination\n      let after = undefined;\n      const allUsers = [];\n      do {\n        const response = await client.users(after ? { after } : undefined);\n        allUsers.push(...(response.users || []));\n        after = response.nextPageToken;\n      } while (after);\n\n      console.log(\\`Found \\${allUsers.length} IDP users to delete\\`);\n\n      for (const user of allUsers) {\n        try {\n          await client.deleteUser(user.id);\n          deleted++;\n          console.log(\\`[_User] Deleted \\${deleted}/\\${allUsers.length}: \\${user.name}\\`);\n        } catch (error) {\n          const message = error instanceof Error ? error.message : String(error);\n          errors.push(\\`User \\${user.id} (\\${user.name}): \\${message}\\`);\n          console.error(\\`[_User] Delete failed for \\${user.name}: \\${message}\\`);\n        }\n      }\n\n      return {\n        success: errors.length === 0,\n        deleted,\n        total: allUsers.length,\n        errors,\n      };\n    }\n  `;\n}\n\ntype GenerateIdpUserSchemaFileOptions = {\n  usernameField: string;\n  userTypeName: string;\n  /**\n   * When `true` (default), emit a foreign key from `_User.name` to the\n   * userProfile type's username field so that seed validation rejects `_User`\n   * rows without a matching userProfile row. Set to `false` to seed `_User`\n   * rows that do not yet have a corresponding userProfile row.\n   */\n  includeUserProfileFK?: boolean;\n};\n\n/**\n * Generates the schema file content for IdP users. Emits the\n * `_User.name -> <userProfile>.<usernameField>` foreign key by default; pass\n * `includeUserProfileFK: false` to omit it (e.g. when seeding `_User` rows\n * that do not yet have a corresponding userProfile row).\n * @param options - Schema generation options\n * @param options.usernameField - Username field name\n * @param options.userTypeName - TailorDB user type name\n * @param options.includeUserProfileFK - Whether to emit the `_User -> userProfile` foreign key (default `true`)\n * @returns Schema file contents\n */\nexport function generateIdpUserSchemaFile(options: GenerateIdpUserSchemaFileOptions): string {\n  const { usernameField, userTypeName, includeUserProfileFK = true } = options;\n  const schemaBody = includeUserProfileFK\n    ? ml`\n      primaryKey: \"name\",\n      indexes: [\n        { name: \"_user_name_unique_idx\", columns: [\"name\"], unique: true },\n      ],\n      foreignKeys: [\n        {\n          column: \"name\",\n          references: {\n            table: \"${userTypeName}\",\n            column: \"${usernameField}\",\n          },\n        },\n      ],\n    `\n    : ml`\n      primaryKey: \"name\",\n      indexes: [\n        { name: \"_user_name_unique_idx\", columns: [\"name\"], unique: true },\n      ],\n    `;\n\n  return ml /* ts */ `\n    import { t } from \"@tailor-platform/sdk\";\n    import { defineSchema } from \"@tailor-platform/sdk/seed\";\n    import { createStandardSchema } from \"@tailor-platform/sdk/test\";\n\n    const schemaType = t.object({\n      name: t.string(),\n      password: t.string(),\n    });\n\n    // Simple identity hook for _User (no TailorDB backing table)\n    export const hook = <T>(data: unknown) => data as T;\n\n    export const schema = defineSchema(\n      createStandardSchema(schemaType, hook),\n      {\n        ${schemaBody}\n      }\n    );\n\n    `;\n}\n","import { isPluginGeneratedType } from \"#/parser/service/tailordb/type-source\";\nimport ml from \"#/utils/multiline\";\nimport type {\n  PluginGeneratedTypeSource,\n  TailorDBType,\n  TypeSourceInfoEntry,\n} from \"#/parser/service/tailordb/types\";\nimport type { LinesDbMetadata } from \"./types\";\nimport type { ForeignKeyDefinition, IndexDefinition } from \"@toiroakr/lines-db\";\n\n/**\n * Processes TailorDB tables to generate lines-db metadata\n * @param type - Parsed TailorDB table\n * @param source - Source file info\n * @returns Generated lines-db metadata\n */\nexport function processLinesDb(type: TailorDBType, source: TypeSourceInfoEntry): LinesDbMetadata {\n  if (isPluginGeneratedType(source)) {\n    // Plugin-generated table\n    return processLinesDbForPluginType(type, source);\n  }\n\n  // User-defined table\n  if (!source.filePath) {\n    throw new Error(`Missing source info for table ${type.name}`);\n  }\n  if (!source.exportName) {\n    throw new Error(`Missing export name for table ${type.name}`);\n  }\n\n  const { optionalFields, omitFields, indexes, foreignKeys } = extractFieldMetadata(type);\n\n  return {\n    typeName: type.name,\n    exportName: source.exportName,\n    importPath: source.filePath,\n    optionalFields,\n    omitFields,\n    foreignKeys,\n    indexes,\n  };\n}\n\n/**\n * Process lines-db metadata for plugin-generated types\n * @param type - Parsed TailorDB table\n * @param source - Plugin-generated table source info\n * @returns Generated lines-db metadata with plugin source\n */\nfunction processLinesDbForPluginType(\n  type: TailorDBType,\n  source: PluginGeneratedTypeSource,\n): LinesDbMetadata {\n  const { optionalFields, omitFields, indexes, foreignKeys } = extractFieldMetadata(type);\n\n  return {\n    typeName: type.name,\n    exportName: source.exportName,\n    importPath: \"\",\n    optionalFields,\n    omitFields,\n    foreignKeys,\n    indexes,\n    pluginSource: source,\n  };\n}\n\n/**\n * Extract field metadata from TailorDB table\n * @param type - Parsed TailorDB table\n * @returns Field metadata including optional fields, omit fields, indexes, and foreign keys\n */\nfunction extractFieldMetadata(type: TailorDBType): {\n  optionalFields: string[];\n  omitFields: string[];\n  indexes: IndexDefinition[];\n  foreignKeys: ForeignKeyDefinition[];\n} {\n  const optionalFields = [\"id\"]; // id is always optional\n  const omitFields: string[] = [];\n  const indexes: IndexDefinition[] = [];\n  const foreignKeys: ForeignKeyDefinition[] = [];\n\n  // Find fields with hooks.create or serial\n  for (const [fieldName, field] of Object.entries(type.fields)) {\n    if (field.config.hooks?.create) {\n      optionalFields.push(fieldName);\n    }\n    // Serial fields are auto-generated, so they should be optional in seed data\n    if (field.config.serial) {\n      omitFields.push(fieldName);\n    }\n    if (field.config.unique) {\n      indexes.push({\n        name: `${type.name.toLowerCase()}_${fieldName}_unique_idx`,\n        columns: [fieldName],\n        unique: true,\n      });\n    }\n  }\n\n  // Extract indexes\n  if (type.indexes) {\n    for (const [indexName, indexDef] of Object.entries(type.indexes)) {\n      indexes.push({\n        name: indexName,\n        columns: indexDef.fields,\n        unique: indexDef.unique,\n      });\n    }\n  }\n\n  // Extract foreign keys from relations\n  for (const [fieldName, field] of Object.entries(type.fields)) {\n    if (field.relation) {\n      foreignKeys.push({\n        column: fieldName,\n        references: {\n          table: field.relation.targetType,\n          column: field.relation.key,\n        },\n      });\n    }\n  }\n\n  return { optionalFields, omitFields, indexes, foreignKeys };\n}\n\n/**\n * Generate schema options code for lines-db\n * @param foreignKeys - Foreign key definitions\n * @param indexes - Index definitions\n * @returns Schema options code string\n */\nfunction generateSchemaOptions(\n  foreignKeys: ForeignKeyDefinition[],\n  indexes: IndexDefinition[],\n): string {\n  const schemaOptions: string[] = [];\n\n  if (foreignKeys.length > 0) {\n    schemaOptions.push(`foreignKeys: [`);\n    foreignKeys.forEach((fk) => {\n      schemaOptions.push(`  ${JSON.stringify(fk)},`);\n    });\n    schemaOptions.push(`],`);\n  }\n\n  if (indexes.length > 0) {\n    schemaOptions.push(`indexes: [`);\n    indexes.forEach((index) => {\n      schemaOptions.push(`  ${JSON.stringify(index)},`);\n    });\n    schemaOptions.push(\"],\");\n  }\n\n  return schemaOptions.length > 0\n    ? [\"\\n  {\", ...schemaOptions.map((option) => `    ${option}`), \"  }\"].join(\"\\n\")\n    : \"\";\n}\n\n/**\n * Generates the schema file content for lines-db (for user-defined tables with import)\n * @param metadata - lines-db metadata\n * @param importPath - Import path for the TailorDB table\n * @returns Schema file contents\n */\nexport function generateLinesDbSchemaFile(metadata: LinesDbMetadata, importPath: string): string {\n  const { exportName, optionalFields, omitFields, foreignKeys, indexes } = metadata;\n\n  const schemaTypeCode = ml /* ts */ `\n    const schemaType = t.object({\n      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),\n      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),\n    });\n    `;\n\n  const schemaOptionsCode = generateSchemaOptions(foreignKeys, indexes);\n\n  return ml /* ts */ `\n    import { t } from \"@tailor-platform/sdk\";\n    import { defineSchema } from \"@tailor-platform/sdk/seed\";\n    import { createTailorDBHook, createStandardSchema } from \"@tailor-platform/sdk/test\";\n    import { ${exportName} } from \"${importPath}\";\n\n    ${schemaTypeCode}\n\n    export const hook = createTailorDBHook(${exportName});\n\n    export const schema = defineSchema(\n      createStandardSchema(schemaType, hook, ${exportName}),${schemaOptionsCode}\n    );\n\n    `;\n}\n\n/**\n * Parameters for generating plugin-type schema file\n */\nexport interface PluginSchemaParams {\n  /** Relative path from schema output to tailor.config.ts */\n  configImportPath: string;\n  /** Relative import path to the original table file (for type-attached plugins) */\n  originalImportPath?: string;\n}\n\n/**\n * Generates the schema file content using getGeneratedType API\n * (for plugin-generated types)\n * @param metadata - lines-db metadata (must have pluginSource)\n * @param params - Plugin import paths\n * @returns Schema file contents\n */\nexport function generateLinesDbSchemaFileWithPluginAPI(\n  metadata: LinesDbMetadata,\n  params: PluginSchemaParams,\n): string {\n  const { typeName, exportName, optionalFields, omitFields, foreignKeys, indexes, pluginSource } =\n    metadata;\n\n  if (!pluginSource) {\n    throw new Error(`pluginSource is required for plugin-generated type \"${typeName}\"`);\n  }\n\n  const { configImportPath, originalImportPath } = params;\n\n  const schemaTypeCode = ml /* ts */ `\n    const schemaType = t.object({\n      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),\n      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),\n    });\n    `;\n\n  const schemaOptionsCode = generateSchemaOptions(foreignKeys, indexes);\n\n  // Type-attached plugin (e.g., changeset): import the original table and use getGeneratedType(configPath, pluginId, type, kind)\n  if (pluginSource.originalExportName && originalImportPath && pluginSource.generatedTypeKind) {\n    return ml /* ts */ `\n    import { join } from \"node:path\";\n    import { t } from \"@tailor-platform/sdk\";\n    import { getGeneratedType } from \"@tailor-platform/sdk/plugin\";\n    import { defineSchema } from \"@tailor-platform/sdk/seed\";\n    import { createTailorDBHook, createStandardSchema } from \"@tailor-platform/sdk/test\";\n    import { ${pluginSource.originalExportName} } from \"${originalImportPath}\";\n\n    const configPath = join(import.meta.dirname, \"${configImportPath}\");\n    const ${exportName} = await getGeneratedType(configPath, \"${pluginSource.pluginId}\", ${pluginSource.originalExportName}, \"${pluginSource.generatedTypeKind}\");\n\n    ${schemaTypeCode}\n\n    export const hook = createTailorDBHook(${exportName});\n\n    export const schema = defineSchema(\n      createStandardSchema(schemaType, hook, ${exportName}),${schemaOptionsCode}\n    );\n\n    `;\n  }\n\n  // Namespace plugin (e.g., audit-log): use getGeneratedType(configPath, pluginId, null, kind)\n  // For namespace plugins, generatedTypeKind is required\n  if (!pluginSource.generatedTypeKind) {\n    throw new Error(\n      `Namespace plugin \"${pluginSource.pluginId}\" must provide generatedTypeKind for type \"${typeName}\"`,\n    );\n  }\n\n  return ml /* ts */ `\n    import { join } from \"node:path\";\n    import { t } from \"@tailor-platform/sdk\";\n    import { getGeneratedType } from \"@tailor-platform/sdk/plugin\";\n    import { defineSchema } from \"@tailor-platform/sdk/seed\";\n    import { createTailorDBHook, createStandardSchema } from \"@tailor-platform/sdk/test\";\n\n    const configPath = join(import.meta.dirname, \"${configImportPath}\");\n    const ${exportName} = await getGeneratedType(configPath, \"${pluginSource.pluginId}\", null, \"${pluginSource.generatedTypeKind}\");\n\n    ${schemaTypeCode}\n\n    export const hook = createTailorDBHook(${exportName});\n\n    export const schema = defineSchema(\n      createStandardSchema(schemaType, hook, ${exportName}),${schemaOptionsCode}\n    );\n\n    `;\n}\n","import * as path from \"pathe\";\nimport { assertDefined } from \"#/utils/assert\";\nimport { processIdpUser, generateIdpUserSchemaFile } from \"./idp-user-processor\";\nimport {\n  processLinesDb,\n  generateLinesDbSchemaFile,\n  generateLinesDbSchemaFileWithPluginAPI,\n  type PluginSchemaParams,\n} from \"./lines-db-processor\";\nimport type { Plugin, GeneratorResult, TailorDBReadyContext } from \"#/plugin/types\";\n\n/** Unique identifier for the seed generator plugin. */\nexport const SeedGeneratorID = \"@tailor-platform/seed\";\n\ntype DisableIdpUserSyncDirections = {\n  /**\n   * Skip emitting the foreign key from `<userProfile>.<usernameField>` to\n   * `_User.name`. Defaults to `false` (FK emitted).\n   *\n   * Set to `true` to seed pre-registration states such as\n   * invited-but-not-registered users.\n   */\n  userToIdp?: boolean;\n  /**\n   * Skip emitting the foreign key from `_User.name` to\n   * `<userProfile>.<usernameField>`. Defaults to `false` (FK emitted).\n   *\n   * Set to `true` to seed `_User` rows that do not yet have a corresponding\n   * userProfile row.\n   */\n  idpToUser?: boolean;\n};\n\nexport type SeedPluginOptions = {\n  distPath: string;\n  machineUserName?: string;\n  /**\n   * Disable individual `_User <-> userProfile` foreign keys emitted into\n   * the generated seed schema. Both directions are emitted by default.\n   *\n   * Set a direction to `true` to relax it — for example to seed invited\n   * users that do not yet have an IdP credential.\n   */\n  disableIdpUserSync?: DisableIdpUserSyncDirections;\n};\n\nfunction resolveIdpUserSyncFKs(option: SeedPluginOptions[\"disableIdpUserSync\"]): {\n  emitUserToIdpFK: boolean;\n  emitIdpToUserFK: boolean;\n} {\n  return {\n    emitUserToIdpFK: !(option?.userToIdp ?? false),\n    emitIdpToUserFK: !(option?.idpToUser ?? false),\n  };\n}\n/**\n * Plugin that generates seed data and schema files consumed by the\n * `tailor seed` commands (@tailor-platform/sdk-plugin-seed).\n * @param options - Plugin options\n * @param options.distPath - Output directory path for generated seed files\n * @param options.machineUserName - Default machine user name for authentication\n * @param options.disableIdpUserSync - Skip emitting individual `_User <-> userProfile` foreign keys. Both directions are emitted by default; set a direction to `true` to relax that side.\n * @returns Plugin instance with onTailorDBReady hook\n */\nexport function seedPlugin(options: SeedPluginOptions): Plugin<unknown, SeedPluginOptions> {\n  return {\n    id: SeedGeneratorID,\n    description: \"Generates seed data and schema files for the tailor seed CLI plugin\",\n    pluginConfig: options,\n\n    async onTailorDBReady(ctx: TailorDBReadyContext<SeedPluginOptions>): Promise<GeneratorResult> {\n      const files: GeneratorResult[\"files\"] = [];\n\n      // Process IdP user early so we can add reverse FK to the user profile type\n      const idpUser = ctx.auth ? (processIdpUser(ctx.auth) ?? null) : null;\n      const idpUserSyncFKs = resolveIdpUserSyncFKs(ctx.pluginConfig.disableIdpUserSync);\n\n      for (const ns of ctx.tailordb) {\n        for (const [typeName, type] of Object.entries(ns.types)) {\n          const source = assertDefined(\n            ns.sourceInfo.get(typeName),\n            `source info missing for type: ${typeName}`,\n          );\n          const linesDb = processLinesDb(type, source);\n\n          // Add reverse FK from userProfile type to _User (opt-out via disableIdpUserSync.userToIdp: true)\n          if (\n            idpUserSyncFKs.emitUserToIdpFK &&\n            idpUser &&\n            typeName === idpUser.schema.userTypeName\n          ) {\n            linesDb.foreignKeys.push({\n              column: idpUser.schema.usernameField,\n              references: {\n                table: \"_User\",\n                column: \"name\",\n              },\n            });\n          }\n\n          // Generate empty JSONL data file\n          files.push({\n            path: path.join(ctx.pluginConfig.distPath, \"data\", `${linesDb.typeName}.jsonl`),\n            content: \"\",\n            skipIfExists: true,\n          });\n\n          const schemaOutputPath = path.join(\n            ctx.pluginConfig.distPath,\n            \"data\",\n            `${linesDb.typeName}.schema.ts`,\n          );\n\n          // Plugin-generated type: use getGeneratedType API\n          if (linesDb.pluginSource && linesDb.pluginSource.pluginImportPath) {\n            // Build original type import path\n            let originalImportPath: string | undefined;\n            if (linesDb.pluginSource.originalFilePath && linesDb.pluginSource.originalExportName) {\n              const relativePath = path.relative(\n                path.dirname(schemaOutputPath),\n                linesDb.pluginSource.originalFilePath,\n              );\n              originalImportPath = relativePath.replace(/\\.ts$/, \"\").startsWith(\".\")\n                ? relativePath.replace(/\\.ts$/, \"\")\n                : `./${relativePath.replace(/\\.ts$/, \"\")}`;\n            }\n\n            // Compute relative path from schema output to config file\n            const configImportPath = path.relative(path.dirname(schemaOutputPath), ctx.configPath);\n\n            const params: PluginSchemaParams = {\n              configImportPath,\n              originalImportPath,\n            };\n\n            const schemaContent = generateLinesDbSchemaFileWithPluginAPI(linesDb, params);\n\n            files.push({\n              path: schemaOutputPath,\n              content: schemaContent,\n            });\n          } else {\n            // User-defined type: import from source file\n            const relativePath = path.relative(path.dirname(schemaOutputPath), linesDb.importPath);\n            const typeImportPath = relativePath.replace(/\\.ts$/, \"\").startsWith(\".\")\n              ? relativePath.replace(/\\.ts$/, \"\")\n              : `./${relativePath.replace(/\\.ts$/, \"\")}`;\n            const schemaContent = generateLinesDbSchemaFile(linesDb, typeImportPath);\n\n            files.push({\n              path: schemaOutputPath,\n              content: schemaContent,\n            });\n          }\n        }\n      }\n\n      if (idpUser) {\n        // Generate empty JSONL data file\n        files.push({\n          path: path.join(ctx.pluginConfig.distPath, idpUser.dataFile),\n          content: \"\",\n          skipIfExists: true,\n        });\n\n        // Generate schema file with foreign key (opt-out via disableIdpUserSync.idpToUser: true)\n        files.push({\n          path: path.join(ctx.pluginConfig.distPath, \"data\", `${idpUser.name}.schema.ts`),\n          content: generateIdpUserSchemaFile({\n            usernameField: idpUser.schema.usernameField,\n            userTypeName: idpUser.schema.userTypeName,\n            includeUserProfileFK: idpUserSyncFKs.emitIdpToUserFK,\n          }),\n        });\n      }\n\n      return { files };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/{service-goqlJJgA.mjs → service-2grcAOCJ.mjs}

@@ -1,5 +1,5 @@
 import { n as isSdkBranded } from "./brand-Eo4pLXPJ.mjs";
-import { n as logger, r as styles } from "./logger-DSdExfor.mjs";
+import { n as logger, r as styles } from "./logger-D0bEznPv.mjs";
 import * as path from "pathe";
 import { z } from "zod";
 import * as fs from "node:fs";
@@ -8,6 +8,40 @@ import { pathToFileURL } from "node:url";
 //#region src/parser/service/common.ts
 const functionSchema = z.custom((val) => typeof val === "function");
 
+//#endregion
+//#region src/cli/shared/user-modules.ts
+const IMPORT_NONCE_PARAM = "tailorImportNonce";
+let runCounter = 0;
+/**
+* Start a fresh user-module run. Modules imported through
+* {@link importUserModule} after this call bypass the ESM cache entries of
+* earlier runs, so a repeated in-process run re-evaluates user code instead
+* of reusing stale modules.
+*/
+function beginUserModuleRun() {
+	runCounter += 1;
+}
+/**
+* Read the cache-busting nonce of the current user-module run.
+* @returns The nonce, or undefined when no run was started
+*/
+function currentImportNonce() {
+	return runCounter === 0 ? void 0 : String(runCounter);
+}
+/**
+* Import a user module (config, workflow, resolver, executor, ...) with the
+* current run's cache-busting nonce applied. Outside a run this is a plain
+* import.
+* @param filePath - Absolute path of the user module
+* @returns The imported module namespace
+*/
+function importUserModule(filePath) {
+	const url = pathToFileURL(filePath);
+	const nonce = currentImportNonce();
+	if (nonce) url.searchParams.set(IMPORT_NONCE_PARAM, nonce);
+	return import(url.href);
+}
+
 //#endregion
 //#region src/cli/services/file-loader.ts
 const DEFAULT_IGNORE_PATTERNS = ["**/*.test.ts", "**/*.spec.ts"];
@@ -67,17 +101,17 @@ const relationTypes = {
 };
 const relationTypesKeys = Object.keys(relationTypes);
 function fieldRef(context) {
-	return `Field "${context.fieldName}" on type "${context.typeName}"`;
+	return `Field "${context.fieldName}" on table "${context.typeName}"`;
 }
 /**
 * Validate relation configuration.
-* @param rawRelation - Raw relation configuration from TailorDB type definition
-* @param context - Context information for the relation (type name, field name, all type names)
+* @param rawRelation - Raw relation configuration from TailorDB table definition
+* @param context - Context information for the relation (table name, field name, all type names)
 */
 function validateRelationConfig(rawRelation, context) {
 	if (!rawRelation.type) throw new Error(`${fieldRef(context)} has a relation but is missing the required 'type' property. Valid values: ${relationTypesKeys.join(", ")}.`);
 	if (!(rawRelation.type in relationTypes)) throw new Error(`${fieldRef(context)} has invalid relation type '${rawRelation.type}'. Valid values: ${relationTypesKeys.join(", ")}.`);
-	if (rawRelation.toward.type !== "self" && !context.allTypeNames.has(rawRelation.toward.type)) throw new Error(`${fieldRef(context)} references unknown type "${rawRelation.toward.type}".`);
+	if (rawRelation.toward.type !== "self" && !context.allTypeNames.has(rawRelation.toward.type)) throw new Error(`${fieldRef(context)} references unknown table "${rawRelation.toward.type}".`);
 }
 /**
 * Process raw relation config and compute derived metadata values.
@@ -166,7 +200,7 @@ const GqlOperationsSchema = z.union([z.literal("query"), z.strictObject({
 	update: z.boolean().optional().describe("Enable update mutation (default: true)"),
 	delete: z.boolean().optional().describe("Enable delete mutation (default: true)"),
 	read: z.boolean().optional().describe("Enable read queries - get, list, aggregation (default: true)")
-})]).describe("Configuration for GraphQL operations on a TailorDB type.\nAll operations are enabled by default (undefined or true = enabled, false = disabled).").transform((val) => normalizeGqlOperations(val));
+})]).describe("Configuration for GraphQL operations on a TailorDB table.\nAll operations are enabled by default (undefined or true = enabled, false = disabled).").transform((val) => normalizeGqlOperations(val));
 const TailorFieldTypeSchema$1 = z.enum([
 	"uuid",
 	"string",
@@ -194,7 +228,7 @@ const DBFieldMetadataSchema = z.strictObject({
 	unique: z.boolean().optional().describe("Whether the field value must be unique"),
 	vector: z.boolean().optional().describe("Whether the field is a vector field for similarity search"),
 	foreignKey: z.boolean().optional().describe("Whether the field is a foreign key"),
-	foreignKeyType: z.string().optional().describe("Target type name for foreign key relations"),
+	foreignKeyType: z.string().optional().describe("Target table name for foreign key relations"),
 	foreignKeyField: z.string().optional().describe("Target field name for foreign key relations"),
 	hooks: z.strictObject({
 		create: functionSchema.optional().describe("Hook function called on record creation"),
@@ -213,11 +247,11 @@ const RelationTypeSchema = z.enum(relationTypesKeys);
 const RawRelationConfigSchema = z.strictObject({
 	type: RelationTypeSchema.describe("Relation cardinality type"),
 	toward: z.strictObject({
-		type: z.string().describe("Target type name, or 'self' for self-relations"),
+		type: z.string().describe("Target table name, or 'self' for self-relations"),
 		as: z.string().optional().describe("Custom forward relation name"),
 		key: z.string().optional().describe("Target field to join on (default: 'id')")
 	}),
-	backward: z.string().optional().describe("Backward relation name on the target type")
+	backward: z.string().optional().describe("Backward relation name on the target table")
 });
 const TailorDBFieldSchema = z.lazy(() => z.object({
 	type: TailorFieldTypeSchema$1,
@@ -226,15 +260,15 @@ const TailorDBFieldSchema = z.lazy(() => z.object({
 	rawRelation: RawRelationConfigSchema.optional()
 }));
 /**
-* Schema for TailorDB type settings.
+* Schema for TailorDB table settings.
 * Normalizes gqlOperations from alias ("query") to object format.
 */
 const TailorDBTypeSettingsSchema = z.strictObject({
-	pluralForm: z.string().optional().describe("Custom plural form of the type name for GraphQL"),
-	aggregation: z.boolean().optional().describe("Enable aggregation queries for this type"),
-	bulkUpsert: z.boolean().optional().describe("Enable bulk upsert mutation for this type"),
-	gqlOperations: GqlOperationsSchema.optional().describe("Configure GraphQL operations for this type. Use \"query\" for read-only mode, or an object for granular control."),
-	publishEvents: z.boolean().optional().describe("Enable publishing events for this type.\nWhen enabled, record creation/update/deletion events are published.\nIf not specified, this is automatically set to true when an executor uses this type\nwith recordCreated/recordUpdated/recordDeleted triggers. If explicitly set to false\nwhile an executor uses this type, an error will be thrown during apply.")
+	pluralForm: z.string().optional().describe("Custom plural form of the table name for GraphQL"),
+	aggregation: z.boolean().optional().describe("Enable aggregation queries for this table"),
+	bulkUpsert: z.boolean().optional().describe("Enable bulk upsert mutation for this table"),
+	gqlOperations: GqlOperationsSchema.optional().describe("Configure GraphQL operations for this table. Use \"query\" for read-only mode, or an object for granular control."),
+	publishEvents: z.boolean().optional().describe("Enable publishing events for this table.\nWhen enabled, record creation/update/deletion events are published.\nIf not specified, this is automatically set to true when an executor uses this table\nwith recordCreated/recordUpdated/recordDeleted triggers. If explicitly set to false\nwhile an executor uses this table, an error will be thrown during apply.")
 });
 const GQL_PERMISSION_INVALID_OPERAND_MESSAGE = "operand is not supported in gqlPermission. Use permission() for record-level conditions.";
 const GqlPermissionOperandSchema = z.union([
@@ -349,10 +383,10 @@ const TailorDBMigrationConfigSchema = z.strictObject({
 * Normalizes gqlOperations from alias ("query") to object format.
 */
 const TailorDBServiceConfigSchema = z.strictObject({
-	files: z.array(z.string()).describe("Glob patterns for TailorDB type definition files"),
-	ignores: z.array(z.string()).optional().describe("Glob patterns to exclude from type discovery"),
+	files: z.array(z.string()).describe("Glob patterns for TailorDB table definition files"),
+	ignores: z.array(z.string()).optional().describe("Glob patterns to exclude from table discovery"),
 	migration: TailorDBMigrationConfigSchema.optional().describe("Migration configuration"),
-	gqlOperations: GqlOperationsSchema.optional().describe("Default GraphQL operations for all types in this service")
+	gqlOperations: GqlOperationsSchema.optional().describe("Default GraphQL operations for all tables in this service")
 });
 
 //#endregion
@@ -543,7 +577,7 @@ const SCIMAttributeMappingSchema = z.strictObject({
 const SCIMResourceSchema = z.strictObject({
 	name: z.string().describe("SCIM resource name"),
 	tailorDBNamespace: z.string().describe("TailorDB namespace for the resource"),
-	tailorDBType: z.string().describe("TailorDB type name for the resource"),
+	tailorDBType: z.string().describe("TailorDB table name for the resource"),
 	coreSchema: SCIMSchemaSchema.describe("Core SCIM schema definition"),
 	attributeMapping: z.array(SCIMAttributeMappingSchema).describe("Attribute mapping configuration")
 });
@@ -553,12 +587,12 @@ const SCIMSchema = z.strictObject({
 	resources: z.array(SCIMResourceSchema).describe("SCIM resource definitions")
 });
 const TenantProviderSchema = z.strictObject({
-	namespace: z.string().describe("TailorDB namespace for the tenant type"),
-	type: z.string().describe("TailorDB type name for tenants"),
+	namespace: z.string().describe("TailorDB namespace for the tenant table"),
+	type: z.string().describe("TailorDB table name for tenants"),
 	signatureField: z.string().describe("Field used as the tenant signature")
 });
 const UserProfileSchema = z.strictObject({
-	namespace: z.string().optional().describe("TailorDB namespace where the user type is defined"),
+	namespace: z.string().optional().describe("TailorDB namespace where the user table is defined"),
 	type: z.custom().transform(stripTailorDBTypeBuilderHelpers).pipe(TailorDBTypeSchema),
 	usernameField: z.string(),
 	attributes: z.record(z.string(), z.literal(true)).optional(),
@@ -610,7 +644,7 @@ const TailorDBTriggerSchema = z.strictObject({
 		"tailordb.type_record.updated",
 		"tailordb.type_record.deleted"
 	])).min(1).transform((arr) => [...new Set(arr)]).describe("TailorDB event types to trigger on"),
-	typeName: z.string().describe("TailorDB type name to watch for events"),
+	typeName: z.string().describe("TailorDB table name to watch for events"),
 	condition: functionSchema.optional().describe("Condition function to filter events")
 });
 const ResolverExecutedTriggerSchema = z.strictObject({
@@ -771,7 +805,7 @@ function stripExecutorTriggerArgs(executor) {
 * @returns Parsed executor or null if invalid
 */
 async function loadExecutor(executorFilePath) {
-	const executor = (await import(pathToFileURL(executorFilePath).href)).default;
+	const executor = (await importUserModule(executorFilePath)).default;
 	const parseResult = ExecutorSchema.safeParse(stripExecutorTriggerArgs(executor));
 	if (!parseResult.success) return null;
 	return parseResult.data;
@@ -791,7 +825,7 @@ function createExecutorService(params) {
 	let loadPromise;
 	const loadExecutorForFile = async (executorFile) => {
 		try {
-			const executorModule = await import(pathToFileURL(executorFile).href);
+			const executorModule = await importUserModule(executorFile);
 			const result = ExecutorSchema.safeParse(stripExecutorTriggerArgs(executorModule.default));
 			if (result.success) {
 				const relativePath = path.relative(process.cwd(), executorFile);
@@ -860,5 +894,5 @@ function assertUniqueExecutorNames(executors) {
 }
 
 //#endregion
-export { AuthConfigSchema as a, stripTailorDBTypeBuilderHelpers as c, applyRelationMetadataToFieldConfig as d, buildRelationInfo as f, functionSchema as g, loadFilesWithIgnores as h, ExecutorSchema as i, TailorDBServiceConfigSchema as l, validateRelationConfig as m, loadExecutor as n, AuthInvokerSchema as o, processRelationMetadata as p, stripExecutorTriggerArgs as r, TailorFieldSchema as s, createExecutorService as t, TailorDBTypeSchema as u };
-//# sourceMappingURL=service-goqlJJgA.mjs.map
+export { beginUserModuleRun as _, AuthConfigSchema as a, functionSchema as b, stripTailorDBTypeBuilderHelpers as c, applyRelationMetadataToFieldConfig as d, buildRelationInfo as f, IMPORT_NONCE_PARAM as g, loadFilesWithIgnores as h, ExecutorSchema as i, TailorDBServiceConfigSchema as l, validateRelationConfig as m, loadExecutor as n, AuthInvokerSchema as o, processRelationMetadata as p, stripExecutorTriggerArgs as r, TailorFieldSchema as s, createExecutorService as t, TailorDBTypeSchema as u, currentImportNonce as v, importUserModule as y };
+//# sourceMappingURL=service-2grcAOCJ.mjs.map