@tailor-platform/sdk 1.17.1 → 1.18.0

package/dist/seed-Dm7lrGZ3.mjs

@@ -0,0 +1,1050 @@
+import { t as isPluginGeneratedType } from "./types-ClK_HJ0G.mjs";
+import * as path from "pathe";
+import ml from "multiline-ts";
+
+//#region src/plugin/builtin/seed/idp-user-processor.ts
+/**
+* Processes auth configuration to generate IdP user seed metadata
+* @param auth - Auth configuration from generator
+* @returns IdP user metadata or undefined if not applicable
+*/
+function processIdpUser(auth) {
+	if (auth.idProvider?.kind !== "BuiltInIdP" || !auth.userProfile) return;
+	const { typeName, usernameField } = auth.userProfile;
+	return {
+		name: "_User",
+		dependencies: [typeName],
+		dataFile: "data/_User.jsonl",
+		idpNamespace: auth.idProvider.namespace,
+		schema: {
+			usernameField,
+			userTypeName: typeName
+		}
+	};
+}
+/**
+* Generates the server-side IDP seed script code for testExecScript execution.
+* Uses the global tailor.idp.Client - no bundling required.
+* @param idpNamespace - The IDP namespace name
+* @returns Script code string
+*/
+function generateIdpSeedScriptCode(idpNamespace) {
+	return ml`
+    export async function main(input) {
+      const client = new tailor.idp.Client({ namespace: "${idpNamespace}" });
+      const errors = [];
+      let processed = 0;
+
+      for (let i = 0; i < input.users.length; i++) {
+        try {
+          await client.createUser(input.users[i]);
+          processed++;
+          console.log(\`[_User] \${i + 1}/\${input.users.length}: \${input.users[i].name}\`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          errors.push(\`Row \${i} (\${input.users[i].name}): \${message}\`);
+          console.error(\`[_User] Row \${i} failed: \${message}\`);
+        }
+      }
+
+      return {
+        success: errors.length === 0,
+        processed,
+        errors,
+      };
+    }
+  `;
+}
+/**
+* Generates the server-side IDP truncation script code for testExecScript execution.
+* Lists all users with pagination and deletes each one.
+* @param idpNamespace - The IDP namespace name
+* @returns Script code string
+*/
+function generateIdpTruncateScriptCode(idpNamespace) {
+	return ml`
+    export async function main() {
+      const client = new tailor.idp.Client({ namespace: "${idpNamespace}" });
+      const errors = [];
+      let deleted = 0;
+
+      // List all users with pagination
+      let nextToken = undefined;
+      const allUsers = [];
+      do {
+        const response = await client.users(nextToken ? { nextToken } : undefined);
+        allUsers.push(...(response.users || []));
+        nextToken = response.nextToken;
+      } while (nextToken);
+
+      console.log(\`Found \${allUsers.length} IDP users to delete\`);
+
+      for (const user of allUsers) {
+        try {
+          await client.deleteUser(user.id);
+          deleted++;
+          console.log(\`[_User] Deleted \${deleted}/\${allUsers.length}: \${user.name}\`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          errors.push(\`User \${user.id} (\${user.name}): \${message}\`);
+          console.error(\`[_User] Delete failed for \${user.name}: \${message}\`);
+        }
+      }
+
+      return {
+        success: errors.length === 0,
+        deleted,
+        total: allUsers.length,
+        errors,
+      };
+    }
+  `;
+}
+/**
+* Generates the schema file content for IdP users with foreign key
+* @param usernameField - Username field name
+* @param userTypeName - TailorDB user type name
+* @returns Schema file contents
+*/
+function generateIdpUserSchemaFile(usernameField, userTypeName) {
+	return ml`
+    import { t } from "@tailor-platform/sdk";
+    import { createStandardSchema } from "@tailor-platform/sdk/test";
+    import { defineSchema } from "@toiroakr/lines-db";
+
+    const schemaType = t.object({
+      name: t.string(),
+      password: t.string(),
+    });
+
+    // Simple identity hook for _User (no TailorDB backing type)
+    const hook = <T>(data: unknown) => data as T;
+
+    export const schema = defineSchema(
+      createStandardSchema(schemaType, hook),
+      {
+        primaryKey: "name",
+        indexes: [
+          { name: "_user_name_unique_idx", columns: ["name"], unique: true },
+        ],
+        foreignKeys: [
+          {
+            column: "name",
+            references: {
+              table: "${userTypeName}",
+              column: "${usernameField}",
+            },
+          },
+        ],
+      }
+    );
+
+    `;
+}
+
+//#endregion
+//#region src/plugin/builtin/seed/lines-db-processor.ts
+/**
+* Processes TailorDB types to generate lines-db metadata
+* @param type - Parsed TailorDB type
+* @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}`);
+	const { optionalFields, omitFields, indexes, foreignKeys } = extractFieldMetadata(type);
+	return {
+		typeName: type.name,
+		exportName: source.exportName,
+		importPath: source.filePath,
+		optionalFields,
+		omitFields,
+		foreignKeys,
+		indexes
+	};
+}
+/**
+* Process lines-db metadata for plugin-generated types
+* @param type - Parsed TailorDB type
+* @param source - Plugin-generated type source info
+* @returns Generated lines-db metadata with plugin source
+*/
+function processLinesDbForPluginType(type, source) {
+	const { optionalFields, omitFields, indexes, foreignKeys } = extractFieldMetadata(type);
+	return {
+		typeName: type.name,
+		exportName: source.exportName,
+		importPath: "",
+		optionalFields,
+		omitFields,
+		foreignKeys,
+		indexes,
+		pluginSource: source
+	};
+}
+/**
+* Extract field metadata from TailorDB type
+* @param type - Parsed TailorDB type
+* @returns Field metadata including optional fields, omit fields, indexes, and foreign keys
+*/
+function extractFieldMetadata(type) {
+	const optionalFields = ["id"];
+	const omitFields = [];
+	const indexes = [];
+	const foreignKeys = [];
+	for (const [fieldName, field] of Object.entries(type.fields)) {
+		if (field.config.hooks?.create) optionalFields.push(fieldName);
+		if (field.config.serial) omitFields.push(fieldName);
+		if (field.config.unique) indexes.push({
+			name: `${type.name.toLowerCase()}_${fieldName}_unique_idx`,
+			columns: [fieldName],
+			unique: true
+		});
+	}
+	if (type.indexes) for (const [indexName, indexDef] of Object.entries(type.indexes)) indexes.push({
+		name: indexName,
+		columns: indexDef.fields,
+		unique: indexDef.unique
+	});
+	for (const [fieldName, field] of Object.entries(type.fields)) if (field.relation) foreignKeys.push({
+		column: fieldName,
+		references: {
+			table: field.relation.targetType,
+			column: field.relation.key
+		}
+	});
+	return {
+		optionalFields,
+		omitFields,
+		indexes,
+		foreignKeys
+	};
+}
+/**
+* Generate schema options code for lines-db
+* @param foreignKeys - Foreign key definitions
+* @param indexes - Index definitions
+* @returns Schema options code string
+*/
+function generateSchemaOptions(foreignKeys, indexes) {
+	const schemaOptions = [];
+	if (foreignKeys.length > 0) {
+		schemaOptions.push(`foreignKeys: [`);
+		foreignKeys.forEach((fk) => {
+			schemaOptions.push(`  ${JSON.stringify(fk)},`);
+		});
+		schemaOptions.push(`],`);
+	}
+	if (indexes.length > 0) {
+		schemaOptions.push(`indexes: [`);
+		indexes.forEach((index) => {
+			schemaOptions.push(`  ${JSON.stringify(index)},`);
+		});
+		schemaOptions.push("],");
+	}
+	return schemaOptions.length > 0 ? [
+		"\n  {",
+		...schemaOptions.map((option) => `    ${option}`),
+		"  }"
+	].join("\n") : "";
+}
+/**
+* Generates the schema file content for lines-db (for user-defined types with import)
+* @param metadata - lines-db metadata
+* @param importPath - Import path for the TailorDB type
+* @returns Schema file contents
+*/
+function generateLinesDbSchemaFile(metadata, importPath) {
+	const { exportName, optionalFields, omitFields, foreignKeys, indexes } = metadata;
+	return ml`
+    import { t } from "@tailor-platform/sdk";
+    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+    import { defineSchema } from "@toiroakr/lines-db";
+    import { ${exportName} } from "${importPath}";
+
+    ${ml`
+    const schemaType = t.object({
+      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),
+      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),
+    });
+    `}
+
+    const hook = createTailorDBHook(${exportName});
+
+    export const schema = defineSchema(
+      createStandardSchema(schemaType, hook),${generateSchemaOptions(foreignKeys, indexes)}
+    );
+
+    `;
+}
+/**
+* Generates the schema file content using getGeneratedType API
+* (for plugin-generated types)
+* @param metadata - lines-db metadata (must have pluginSource)
+* @param params - Plugin import paths
+* @returns Schema file contents
+*/
+function generateLinesDbSchemaFileWithPluginAPI(metadata, params) {
+	const { typeName, exportName, optionalFields, omitFields, foreignKeys, indexes, pluginSource } = metadata;
+	if (!pluginSource) throw new Error(`pluginSource is required for plugin-generated type "${typeName}"`);
+	const { configImportPath, originalImportPath } = params;
+	const schemaTypeCode = ml`
+    const schemaType = t.object({
+      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),
+      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),
+    });
+    `;
+	const schemaOptionsCode = generateSchemaOptions(foreignKeys, indexes);
+	if (pluginSource.originalExportName && originalImportPath && pluginSource.generatedTypeKind) return ml`
+    import { join } from "node:path";
+    import { t } from "@tailor-platform/sdk";
+    import { getGeneratedType } from "@tailor-platform/sdk/plugin";
+    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+    import { defineSchema } from "@toiroakr/lines-db";
+    import { ${pluginSource.originalExportName} } from "${originalImportPath}";
+
+    const configPath = join(import.meta.dirname, "${configImportPath}");
+    const ${exportName} = await getGeneratedType(configPath, "${pluginSource.pluginId}", ${pluginSource.originalExportName}, "${pluginSource.generatedTypeKind}");
+
+    ${schemaTypeCode}
+
+    const hook = createTailorDBHook(${exportName});
+
+    export const schema = defineSchema(
+      createStandardSchema(schemaType, hook),${schemaOptionsCode}
+    );
+
+    `;
+	if (!pluginSource.generatedTypeKind) throw new Error(`Namespace plugin "${pluginSource.pluginId}" must provide generatedTypeKind for type "${typeName}"`);
+	return ml`
+    import { join } from "node:path";
+    import { t } from "@tailor-platform/sdk";
+    import { getGeneratedType } from "@tailor-platform/sdk/plugin";
+    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+    import { defineSchema } from "@toiroakr/lines-db";
+
+    const configPath = join(import.meta.dirname, "${configImportPath}");
+    const ${exportName} = await getGeneratedType(configPath, "${pluginSource.pluginId}", null, "${pluginSource.generatedTypeKind}");
+
+    ${schemaTypeCode}
+
+    const hook = createTailorDBHook(${exportName});
+
+    export const schema = defineSchema(
+      createStandardSchema(schemaType, hook),${schemaOptionsCode}
+    );
+
+    `;
+}
+
+//#endregion
+//#region src/plugin/builtin/seed/seed-type-processor.ts
+/**
+* Processes TailorDB types to extract seed type information
+* @param type - Parsed TailorDB type
+* @param namespace - Namespace of the type
+* @returns Seed type information
+*/
+function processSeedTypeInfo(type, namespace) {
+	const dependencies = Array.from(Object.values(type.fields).reduce((set, field) => {
+		const targetType = field.relation?.targetType ?? field.config.foreignKeyType;
+		if (targetType && targetType !== type.name) set.add(targetType);
+		return set;
+	}, /* @__PURE__ */ new Set()));
+	return {
+		name: type.name,
+		namespace,
+		dependencies,
+		dataFile: `data/${type.name}.jsonl`
+	};
+}
+
+//#endregion
+//#region src/plugin/builtin/seed/index.ts
+const SeedGeneratorID = "@tailor-platform/seed";
+/**
+* Generate the IdP user seed function code using tailor.idp.Client via testExecScript
+* @param hasIdpUser - Whether IdP user is included
+* @param idpNamespace - The IDP namespace name
+* @returns JavaScript code for IdP user seeding function
+*/
+function generateIdpUserSeedFunction(hasIdpUser, idpNamespace) {
+	if (!hasIdpUser || !idpNamespace) return "";
+	return ml`
+    // Seed _User via tailor.idp.Client (server-side)
+    const seedIdpUser = async () => {
+      console.log(styleText("cyan", "  Seeding _User via tailor.idp.Client..."));
+      const dataDir = join(configDir, "data");
+      const data = loadSeedData(dataDir, ["_User"]);
+      const rows = data["_User"] || [];
+      if (rows.length === 0) {
+        console.log(styleText("dim", "    No _User data to seed"));
+        return { success: true };
+      }
+      console.log(styleText("dim", \`    Processing \${rows.length} _User records...\`));
+
+      const idpSeedCode = \/* js *\/\`${generateIdpSeedScriptCode(idpNamespace).replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;
+
+      const result = await executeScript({
+        client: operatorClient,
+        workspaceId,
+        name: "seed-idp-user.ts",
+        code: idpSeedCode,
+        arg: JSON.stringify({ users: rows }),
+        invoker: {
+          namespace: authNamespace,
+          machineUserName,
+        },
+      });
+
+      if (result.logs) {
+        for (const line of result.logs.split("\\n").filter(Boolean)) {
+          console.log(styleText("dim", \`    \${line}\`));
+        }
+      }
+
+      if (result.success) {
+        let parsed;
+        try {
+          parsed = JSON.parse(result.result || "{}");
+        } catch (e) {
+          console.error(styleText("red", \`    ✗ Failed to parse seed result: \${e.message}\`));
+          return { success: false };
+        }
+
+        if (parsed.processed) {
+          console.log(styleText("green", \`    ✓ _User: \${parsed.processed} rows processed\`));
+        }
+
+        if (!parsed.success) {
+          const errors = Array.isArray(parsed.errors) ? parsed.errors : [];
+          for (const err of errors) {
+            console.error(styleText("red", \`    ✗ \${err}\`));
+          }
+          return { success: false };
+        }
+
+        return { success: true };
+      } else {
+        console.error(styleText("red", \`    ✗ Seed failed: \${result.error}\`));
+        return { success: false };
+      }
+    };
+  `;
+}
+/**
+* Generate the IdP user seed call code
+* @param hasIdpUser - Whether IdP user is included
+* @returns JavaScript code for calling IdP user seeding
+*/
+function generateIdpUserSeedCall(hasIdpUser) {
+	if (!hasIdpUser) return "";
+	return ml`
+    // Seed _User if included and not skipped
+    const shouldSeedUser = !skipIdp && (!entitiesToProcess || entitiesToProcess.includes("_User"));
+    if (hasIdpUser && shouldSeedUser) {
+      const result = await seedIdpUser();
+      if (!result.success) {
+        allSuccess = false;
+      }
+    }
+  `;
+}
+/**
+* Generate the IdP user truncation function code using tailor.idp.Client via testExecScript
+* @param hasIdpUser - Whether IdP user is included
+* @param idpNamespace - The IDP namespace name
+* @returns JavaScript code for IdP user truncation function
+*/
+function generateIdpUserTruncateFunction(hasIdpUser, idpNamespace) {
+	if (!hasIdpUser || !idpNamespace) return "";
+	return ml`
+    // Truncate _User via tailor.idp.Client (server-side)
+    const truncateIdpUser = async () => {
+      console.log(styleText("cyan", "Truncating _User via tailor.idp.Client..."));
+
+      const idpTruncateCode = \/* js *\/\`${generateIdpTruncateScriptCode(idpNamespace).replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;
+
+      const result = await executeScript({
+        client: operatorClient,
+        workspaceId,
+        name: "truncate-idp-user.ts",
+        code: idpTruncateCode,
+        arg: JSON.stringify({}),
+        invoker: {
+          namespace: authNamespace,
+          machineUserName,
+        },
+      });
+
+      if (result.logs) {
+        for (const line of result.logs.split("\\n").filter(Boolean)) {
+          console.log(styleText("dim", \`  \${line}\`));
+        }
+      }
+
+      if (result.success) {
+        let parsed;
+        try {
+          parsed = JSON.parse(result.result || "{}");
+        } catch (e) {
+          console.error(styleText("red", \`  ✗ Failed to parse truncation result: \${e.message}\`));
+          return { success: false };
+        }
+
+        if (parsed.deleted !== undefined) {
+          console.log(styleText("green", \`  ✓ _User: \${parsed.deleted} users deleted\`));
+        }
+
+        if (!parsed.success) {
+          const errors = Array.isArray(parsed.errors) ? parsed.errors : [];
+          for (const err of errors) {
+            console.error(styleText("red", \`  ✗ \${err}\`));
+          }
+          return { success: false };
+        }
+
+        return { success: true };
+      } else {
+        console.error(styleText("red", \`  ✗ Truncation failed: \${result.error}\`));
+        return { success: false };
+      }
+    };
+  `;
+}
+/**
+* Generate the IdP user truncation call code within the truncate block
+* @param hasIdpUser - Whether IdP user is included
+* @returns JavaScript code for calling IdP user truncation
+*/
+function generateIdpUserTruncateCall(hasIdpUser) {
+	if (!hasIdpUser) return "";
+	return ml`
+    // Truncate _User if applicable
+    const shouldTruncateUser = !skipIdp && !hasNamespace && (!hasTypes || entitiesToProcess.includes("_User"));
+    if (hasIdpUser && shouldTruncateUser) {
+      const truncResult = await truncateIdpUser();
+      if (!truncResult.success) {
+        console.error(styleText("red", "IDP user truncation failed."));
+        process.exit(1);
+      }
+    }
+  `;
+}
+/**
+* Generates the exec.mjs script content using testExecScript API for TailorDB types
+* and tailor.idp.Client for _User (IdP managed)
+* @param defaultMachineUserName - Default machine user name from generator config (can be overridden at runtime)
+* @param relativeConfigPath - Config path relative to exec script
+* @param namespaceConfigs - Namespace configurations with types and dependencies
+* @param hasIdpUser - Whether _User is included
+* @param idpNamespace - The IDP namespace name, or null if not applicable
+* @returns exec.mjs file contents
+*/
+function generateExecScript(defaultMachineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser, idpNamespace) {
+	const namespaceEntitiesEntries = namespaceConfigs.map(({ namespace, types }) => {
+		return `      "${namespace}": [\n${types.map((e) => `        "${e}",`).join("\n")}\n      ]`;
+	}).join(",\n");
+	const namespaceDepsEntries = namespaceConfigs.map(({ namespace, dependencies }) => {
+		return `      "${namespace}": {\n${Object.entries(dependencies).map(([type, deps]) => `        "${type}": [${deps.map((d) => `"${d}"`).join(", ")}]`).join(",\n")}\n      }`;
+	}).join(",\n");
+	return ml`
+    import { readFileSync } from "node:fs";
+    import { join } from "node:path";
+    import { parseArgs, styleText } from "node:util";
+    import { createInterface } from "node:readline";
+    import {
+      show,
+      truncate,
+      bundleSeedScript,
+      chunkSeedData,
+      executeScript,
+      initOperatorClient,
+      loadAccessToken,
+      loadWorkspaceId,
+    } from "@tailor-platform/sdk/cli";
+
+    // Parse command-line arguments
+    const { values, positionals } = parseArgs({
+      options: {
+        "machine-user": { type: "string", short: "m" },
+        namespace: { type: "string", short: "n" },
+        "skip-idp": { type: "boolean", default: false },
+        truncate: { type: "boolean", default: false },
+        yes: { type: "boolean", default: false },
+        profile: { type: "string", short: "p" },
+        help: { type: "boolean", short: "h", default: false },
+      },
+      allowPositionals: true,
+    });
+
+    if (values.help) {
+      console.log(\`
+    Usage: node exec.mjs [options] [types...]
+
+    Options:
+      -m, --machine-user <name> Machine user name for authentication (required if not configured)
+      -n, --namespace <ns>      Process all types in specified namespace (excludes _User)
+      --skip-idp                Skip IdP user (_User) entity
+      --truncate                Truncate tables before seeding
+      --yes                     Skip confirmation prompts (for truncate)
+      -p, --profile <name>      Workspace profile name
+      -h, --help                Show help
+
+    Examples:
+      node exec.mjs -m admin                            # Process all types with machine user
+      node exec.mjs --namespace <namespace>             # Process tailordb namespace only (no _User)
+      node exec.mjs User Order                          # Process specific types only
+      node exec.mjs --skip-idp                          # Process all except _User
+      node exec.mjs --truncate                          # Truncate all tables, then seed all
+      node exec.mjs --truncate --yes                    # Truncate all tables without confirmation, then seed all
+      node exec.mjs --truncate --namespace <namespace>  # Truncate tailordb, then seed tailordb
+      node exec.mjs --truncate User Order               # Truncate User and Order, then seed them
+      \`);
+      process.exit(0);
+    }
+
+    // Helper function to prompt for y/n confirmation
+    const promptConfirmation = (question) => {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      return new Promise((resolve) => {
+        rl.question(styleText("yellow", question), (answer) => {
+          rl.close();
+          resolve(answer.toLowerCase().trim());
+        });
+      });
+    };
+
+    const configDir = import.meta.dirname;
+    const configPath = join(configDir, "${relativeConfigPath}");
+
+    // Determine machine user name (CLI argument takes precedence over config default)
+    const defaultMachineUser = ${defaultMachineUserName ? `"${defaultMachineUserName}"` : "undefined"};
+    const machineUserName = values["machine-user"] || defaultMachineUser;
+
+    if (!machineUserName) {
+      console.error(styleText("red", "Error: Machine user name is required."));
+      console.error(styleText("yellow", "Specify --machine-user <name> or configure machineUserName in generator options."));
+      process.exit(1);
+    }
+
+    // Entity configuration
+    const namespaceEntities = {
+${namespaceEntitiesEntries}
+    };
+    const namespaceDeps = {
+${namespaceDepsEntries}
+    };
+    const entities = Object.values(namespaceEntities).flat();
+    const hasIdpUser = ${String(hasIdpUser)};
+
+    // Determine which entities to process
+    let entitiesToProcess = null;
+
+    const hasNamespace = !!values.namespace;
+    const hasTypes = positionals.length > 0;
+    const skipIdp = values["skip-idp"];
+
+    // Validate mutually exclusive options
+    const optionCount = [hasNamespace, hasTypes].filter(Boolean).length;
+    if (optionCount > 1) {
+      console.error(styleText("red", "Error: Options --namespace and type names are mutually exclusive."));
+      process.exit(1);
+    }
+
+    // --skip-idp and --namespace are redundant (namespace already excludes _User)
+    if (skipIdp && hasNamespace) {
+      console.warn(styleText("yellow", "Warning: --skip-idp is redundant with --namespace (namespace filtering already excludes _User)."));
+    }
+
+    // Filter by namespace (automatically excludes _User as it has no namespace)
+    if (hasNamespace) {
+      const namespace = values.namespace;
+      entitiesToProcess = namespaceEntities[namespace];
+
+      if (!entitiesToProcess || entitiesToProcess.length === 0) {
+        console.error(styleText("red", \`Error: No entities found in namespace "\${namespace}"\`));
+        console.error(styleText("yellow", \`Available namespaces: \${Object.keys(namespaceEntities).join(", ")}\`));
+        process.exit(1);
+      }
+
+      console.log(styleText("cyan", \`Filtering by namespace: \${namespace}\`));
+      console.log(styleText("dim", \`Entities: \${entitiesToProcess.join(", ")}\`));
+    }
+
+    // Filter by specific types
+    if (hasTypes) {
+      const requestedTypes = positionals;
+      const notFoundTypes = [];
+      const allTypes = hasIdpUser ? [...entities, "_User"] : entities;
+
+      entitiesToProcess = requestedTypes.filter((type) => {
+        if (!allTypes.includes(type)) {
+          notFoundTypes.push(type);
+          return false;
+        }
+        return true;
+      });
+
+      if (notFoundTypes.length > 0) {
+        console.error(styleText("red", \`Error: The following types were not found: \${notFoundTypes.join(", ")}\`));
+        console.error(styleText("yellow", \`Available types: \${allTypes.join(", ")}\`));
+        process.exit(1);
+      }
+
+      console.log(styleText("cyan", \`Filtering by types: \${entitiesToProcess.join(", ")}\`));
+    }
+
+    // Apply --skip-idp filter
+    if (skipIdp) {
+      if (entitiesToProcess) {
+        entitiesToProcess = entitiesToProcess.filter((entity) => entity !== "_User");
+      } else {
+        entitiesToProcess = entities.filter((entity) => entity !== "_User");
+      }
+    }
+
+    // Get application info
+    const appInfo = await show({ configPath, profile: values.profile });
+    const authNamespace = appInfo.auth;
+
+    // Initialize operator client (once for all namespaces)
+    const accessToken = await loadAccessToken({ profile: values.profile, useProfile: true });
+    const workspaceId = await loadWorkspaceId({ profile: values.profile });
+    const operatorClient = await initOperatorClient(accessToken);
+
+    ${generateIdpUserTruncateFunction(hasIdpUser, idpNamespace)}
+
+    // Truncate tables if requested
+    if (values.truncate) {
+      const answer = values.yes ? "y" : await promptConfirmation("Are you sure you want to truncate? (y/n): ");
+      if (answer !== "y") {
+        console.log(styleText("yellow", "Truncate cancelled."));
+        process.exit(0);
+      }
+
+      console.log(styleText("cyan", "Truncating tables..."));
+
+      try {
+        if (hasNamespace) {
+          await truncate({
+            configPath,
+            profile: values.profile,
+            namespace: values.namespace,
+          });
+        } else if (hasTypes) {
+          const typesToTruncate = entitiesToProcess.filter((t) => t !== "_User");
+          if (typesToTruncate.length > 0) {
+            await truncate({
+              configPath,
+              profile: values.profile,
+              types: typesToTruncate,
+            });
+          } else {
+            console.log(styleText("dim", "No TailorDB types to truncate (only _User was specified)."));
+          }
+        } else {
+          await truncate({
+            configPath,
+            profile: values.profile,
+            all: true,
+          });
+        }
+      } catch (error) {
+        console.error(styleText("red", \`Truncate failed: \${error.message}\`));
+        process.exit(1);
+      }
+
+      ${generateIdpUserTruncateCall(hasIdpUser)}
+
+      console.log(styleText("green", "Truncate completed."));
+    }
+
+    console.log(styleText("cyan", "\\nStarting seed data generation..."));
+    if (skipIdp) {
+      console.log(styleText("dim", \`  Skipping IdP user (_User)\`));
+    }
+
+    // Load seed data from JSONL files
+    const loadSeedData = (dataDir, typeNames) => {
+      const data = {};
+      for (const typeName of typeNames) {
+        const jsonlPath = join(dataDir, \`\${typeName}.jsonl\`);
+        try {
+          const content = readFileSync(jsonlPath, "utf-8").trim();
+          if (content) {
+            data[typeName] = content.split("\\n").map((line) => JSON.parse(line));
+          } else {
+            data[typeName] = [];
+          }
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            data[typeName] = [];
+          } else {
+            throw error;
+          }
+        }
+      }
+      return data;
+    };
+
+    // Topological sort for dependency order
+    const topologicalSort = (types, deps) => {
+      const visited = new Set();
+      const result = [];
+
+      const visit = (type) => {
+        if (visited.has(type)) return;
+        visited.add(type);
+        const typeDeps = deps[type] || [];
+        for (const dep of typeDeps) {
+          if (types.includes(dep)) {
+            visit(dep);
+          }
+        }
+        result.push(type);
+      };
+
+      for (const type of types) {
+        visit(type);
+      }
+      return result;
+    };
+
+    // Seed TailorDB types via testExecScript
+    const seedViaTestExecScript = async (namespace, typesToSeed, deps) => {
+      const dataDir = join(configDir, "data");
+      const sortedTypes = topologicalSort(typesToSeed, deps);
+      const data = loadSeedData(dataDir, sortedTypes);
+
+      // Skip if no data
+      const typesWithData = sortedTypes.filter((t) => data[t] && data[t].length > 0);
+      if (typesWithData.length === 0) {
+        console.log(styleText("dim", \`  [\${namespace}] No data to seed\`));
+        return { success: true, processed: {} };
+      }
+
+      console.log(styleText("cyan", \`  [\${namespace}] Seeding \${typesWithData.length} types via Kysely batch insert...\`));
+
+      // Bundle seed script
+      const bundled = await bundleSeedScript(namespace, typesWithData);
+
+      // Chunk seed data to fit within gRPC message size limits
+      const chunks = chunkSeedData({
+        data,
+        order: sortedTypes,
+        codeByteSize: new TextEncoder().encode(bundled.bundledCode).length,
+      });
+
+      if (chunks.length === 0) {
+        console.log(styleText("dim", \`  [\${namespace}] No data to seed\`));
+        return { success: true, processed: {} };
+      }
+
+      if (chunks.length > 1) {
+        console.log(styleText("dim", \`    Split into \${chunks.length} chunks\`));
+      }
+
+      const allProcessed = {};
+      let hasError = false;
+      const allErrors = [];
+
+      for (const chunk of chunks) {
+        if (chunks.length > 1) {
+          console.log(styleText("dim", \`    Chunk \${chunk.index + 1}/\${chunk.total}: \${chunk.order.join(", ")}\`));
+        }
+
+        // Execute seed script for this chunk
+        const result = await executeScript({
+          client: operatorClient,
+          workspaceId,
+          name: \`seed-\${namespace}.ts\`,
+          code: bundled.bundledCode,
+          arg: JSON.stringify({ data: chunk.data, order: chunk.order }),
+          invoker: {
+            namespace: authNamespace,
+            machineUserName,
+          },
+        });
+
+        // Parse result and display logs
+        if (result.logs) {
+          for (const line of result.logs.split("\\n").filter(Boolean)) {
+            console.log(styleText("dim", \`    \${line}\`));
+          }
+        }
+
+        if (result.success) {
+          let parsed;
+          try {
+            const parsedResult = JSON.parse(result.result || "{}");
+            parsed = parsedResult && typeof parsedResult === "object" ? parsedResult : {};
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(styleText("red", \`    ✗ Failed to parse seed result: \${message}\`));
+            hasError = true;
+            allErrors.push(message);
+            continue;
+          }
+
+          const processed = parsed.processed || {};
+          for (const [type, count] of Object.entries(processed)) {
+            allProcessed[type] = (allProcessed[type] || 0) + count;
+            console.log(styleText("green", \`    ✓ \${type}: \${count} rows inserted\`));
+          }
+
+          if (!parsed.success) {
+            const errors = Array.isArray(parsed.errors) ? parsed.errors : [];
+            const errorMessage =
+              errors.length > 0 ? errors.join("\\n        ") : "Seed script reported failure";
+            console.error(styleText("red", \`    ✗ Seed failed:\\n        \${errorMessage}\`));
+            hasError = true;
+            allErrors.push(errorMessage);
+          }
+        } else {
+          console.error(styleText("red", \`    ✗ Seed failed: \${result.error}\`));
+          hasError = true;
+          allErrors.push(result.error);
+        }
+      }
+
+      if (hasError) {
+        return { success: false, error: allErrors.join("\\n") };
+      }
+      return { success: true, processed: allProcessed };
+    };
+
+    ${generateIdpUserSeedFunction(hasIdpUser, idpNamespace)}
+
+    // Main execution
+    try {
+      let allSuccess = true;
+
+      // Determine which namespaces and types to process
+      const namespacesToProcess = hasNamespace
+        ? [values.namespace]
+        : Object.keys(namespaceEntities);
+
+      for (const namespace of namespacesToProcess) {
+        const nsTypes = namespaceEntities[namespace] || [];
+        const nsDeps = namespaceDeps[namespace] || {};
+
+        // Filter types if specific types requested
+        let typesToSeed = entitiesToProcess
+          ? nsTypes.filter((t) => entitiesToProcess.includes(t))
+          : nsTypes;
+
+        if (typesToSeed.length === 0) continue;
+
+        const result = await seedViaTestExecScript(namespace, typesToSeed, nsDeps);
+        if (!result.success) {
+          allSuccess = false;
+        }
+      }
+
+      ${generateIdpUserSeedCall(hasIdpUser)}
+
+      if (allSuccess) {
+        console.log(styleText("green", "\\n✓ Seed data generation completed successfully"));
+      } else {
+        console.error(styleText("red", "\\n✗ Seed data generation completed with errors"));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(styleText("red", \`\\n✗ Seed data generation failed: \${error.message}\`));
+      process.exit(1);
+    }
+
+    `;
+}
+/**
+* Plugin that generates seed data files with Kysely batch insert and tailor.idp.Client for _User.
+* @param options - Plugin options
+* @param options.distPath - Output directory path for generated seed files
+* @param options.machineUserName - Default machine user name for authentication
+* @returns Plugin instance with onTailorDBReady hook
+*/
+function seedPlugin(options) {
+	return {
+		id: SeedGeneratorID,
+		description: "Generates seed data files (Kysely batch insert + tailor.idp.Client for _User)",
+		pluginConfig: options,
+		async onTailorDBReady(ctx) {
+			const files = [];
+			const namespaceConfigs = [];
+			for (const ns of ctx.tailordb) {
+				const types = [];
+				const dependencies = {};
+				for (const [typeName, type] of Object.entries(ns.types)) {
+					const source = ns.sourceInfo.get(typeName);
+					const typeInfo = processSeedTypeInfo(type, ns.namespace);
+					const linesDb = processLinesDb(type, source);
+					types.push(typeInfo.name);
+					dependencies[typeInfo.name] = typeInfo.dependencies;
+					files.push({
+						path: path.join(ctx.pluginConfig.distPath, typeInfo.dataFile),
+						content: "",
+						skipIfExists: true
+					});
+					const schemaOutputPath = path.join(ctx.pluginConfig.distPath, "data", `${linesDb.typeName}.schema.ts`);
+					if (linesDb.pluginSource && linesDb.pluginSource.pluginImportPath) {
+						let originalImportPath;
+						if (linesDb.pluginSource.originalFilePath && linesDb.pluginSource.originalExportName) {
+							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, {
+							configImportPath: path.relative(path.dirname(schemaOutputPath), ctx.configPath),
+							originalImportPath
+						});
+						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$/, "")}`);
+						files.push({
+							path: schemaOutputPath,
+							content: schemaContent
+						});
+					}
+				}
+				namespaceConfigs.push({
+					namespace: ns.namespace,
+					types,
+					dependencies
+				});
+			}
+			const idpUser = ctx.auth ? processIdpUser(ctx.auth) : null;
+			const hasIdpUser = idpUser !== null;
+			if (idpUser) {
+				files.push({
+					path: path.join(ctx.pluginConfig.distPath, idpUser.dataFile),
+					content: "",
+					skipIfExists: true
+				});
+				files.push({
+					path: path.join(ctx.pluginConfig.distPath, "data", `${idpUser.name}.schema.ts`),
+					content: generateIdpUserSchemaFile(idpUser.schema.usernameField, idpUser.schema.userTypeName)
+				});
+			}
+			const relativeConfigPath = path.relative(ctx.pluginConfig.distPath, ctx.configPath);
+			files.push({
+				path: path.join(ctx.pluginConfig.distPath, "exec.mjs"),
+				content: generateExecScript(ctx.pluginConfig.machineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser, idpUser?.idpNamespace ?? null)
+			});
+			return { files };
+		}
+	};
+}
+
+//#endregion
+export { seedPlugin as n, SeedGeneratorID as t };
+//# sourceMappingURL=seed-Dm7lrGZ3.mjs.map