@tailor-platform/sdk 1.9.2 → 1.10.0

package/dist/{update-DZs1loy_.mjs → update-C877GWkA.mjs}

@@ -1,4 +1,4 @@
-import { a as OAuth2ClientSchema, c as tailorUserMap, d as styles, f as symbols, i as ExecutorSchema, l as loadFilesWithIgnores, n as WorkflowJobSchema, o as ResolverSchema, r as WorkflowSchema, s as stringifyFunction, t as defineApplication, u as logger } from "./application-_ArEfxmV.mjs";
+import { a as OAuth2ClientSchema, c as tailorUserMap, d as styles, f as symbols, i as ExecutorSchema, l as loadFilesWithIgnores, n as WorkflowJobSchema, o as ResolverSchema, r as WorkflowSchema, s as stringifyFunction, t as defineApplication, u as logger } from "./application-R26DC-sK.mjs";
 import { createRequire } from "node:module";
 import { arg, defineCommand } from "politty";
 import { z } from "zod";
@@ -519,7 +519,7 @@ const file_tailor_v1_function_registry = /* @__PURE__ */ fileDesc("CiF0YWlsb3Ivd
 /**
 * Describes the file tailor/v1/idp_resource.proto.
 */
-const file_tailor_v1_idp_resource = /* @__PURE__ */ fileDesc("Chx0YWlsb3IvdjEvaWRwX3Jlc291cmNlLnByb3RvEgl0YWlsb3IudjEi3gEKCklkUFNlcnZpY2USJwoJbmFtZXNwYWNlGAEgASgLMhQudGFpbG9yLnYxLk5hbWVzcGFjZRIVCg1hdXRob3JpemF0aW9uGAIgASgJEhkKDHByb3ZpZGVyX3VybBgDIAEoCUID4EEDEjYKEHVzZXJfYXV0aF9wb2xpY3kYBCABKAsyHC50YWlsb3IudjEuSWRQVXNlckF1dGhQb2xpY3kSIAoEbGFuZxgFIAEoDjISLnRhaWxvci52MS5JZFBMYW5nEhsKE3B1Ymxpc2hfdXNlcl9ldmVudHMYBiABKAgiTQoJSWRQQ2xpZW50EgwKBG5hbWUYASABKAkSFgoJY2xpZW50X2lkGAIgASgJQgPgQQMSGgoNY2xpZW50X3NlY3JldBgDIAEoCUID4EEDIrcGChFJZFBVc2VyQXV0aFBvbGljeRIgChh1c2Vfbm9uX2VtYWlsX2lkZW50aWZpZXIYASABKAgSIQoZYWxsb3dfc2VsZl9wYXNzd29yZF9yZXNldBgCIAEoCBIiChpwYXNzd29yZF9yZXF1aXJlX3VwcGVyY2FzZRgDIAEoCBIiChpwYXNzd29yZF9yZXF1aXJlX2xvd2VyY2FzZRgEIAEoCBIpCiFwYXNzd29yZF9yZXF1aXJlX25vbl9hbHBoYW51bWVyaWMYBSABKAgSIAoYcGFzc3dvcmRfcmVxdWlyZV9udW1lcmljGAYgASgIEqYBChNwYXNzd29yZF9taW5fbGVuZ3RoGAcgASgFQogBukiEAboBgAEKGXBhc3N3b3JkX21pbl9sZW5ndGhfcmFuZ2USO3Bhc3N3b3JkX21pbl9sZW5ndGggbXVzdCBiZSAwIChkZWZhdWx0KSBvciBiZXR3ZWVuIDYgYW5kIDMwGiZ0aGlzID09IDAgfHwgKHRoaXMgPj0gNiAmJiB0aGlzIDw9IDMwKRKqAQoTcGFzc3dvcmRfbWF4X2xlbmd0aBgIIAEoBUKMAbpIiAG6AYQBChlwYXNzd29yZF9tYXhfbGVuZ3RoX3JhbmdlEj1wYXNzd29yZF9tYXhfbGVuZ3RoIG11c3QgYmUgMCAoZGVmYXVsdCkgb3IgYmV0d2VlbiA2IGFuZCA0MDk2Gih0aGlzID09IDAgfHwgKHRoaXMgPj0gNiAmJiB0aGlzIDw9IDQwOTYpOvEBukjtARrqAQobcGFzc3dvcmRfbGVuZ3RoX2NvbnNpc3RlbmN5EkVwYXNzd29yZF9taW5fbGVuZ3RoIG11c3QgYmUgbGVzcyB0aGFuIG9yIGVxdWFsIHRvIHBhc3N3b3JkX21heF9sZW5ndGgagwEodGhpcy5wYXNzd29yZF9taW5fbGVuZ3RoID09IDAgPyA2IDogdGhpcy5wYXNzd29yZF9taW5fbGVuZ3RoKSA8PSAodGhpcy5wYXNzd29yZF9tYXhfbGVuZ3RoID09IDAgPyA0MDk2IDogdGhpcy5wYXNzd29yZF9tYXhfbGVuZ3RoKSpICgdJZFBMYW5nEhkKFUlEX1BfTEFOR19VTlNQRUNJRklFRBAAEhAKDElEX1BfTEFOR19FThABEhAKDElEX1BfTEFOR19KQRACYgZwcm90bzM", [
+const file_tailor_v1_idp_resource = /* @__PURE__ */ fileDesc("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", [
 	file_buf_validate_validate,
 	file_google_api_field_behavior,
 	file_tailor_v1_resource
@@ -930,7 +930,8 @@ function waitRetryBackoff(attempt) {
 function isRetirable(error, idempotency) {
 	if (!(error instanceof ConnectError)) return false;
 	switch (error.code) {
-		case Code.ResourceExhausted | Code.Unavailable: return true;
+		case Code.ResourceExhausted:
+		case Code.Unavailable: return true;
 		case Code.Internal: return idempotency === MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS || idempotency === MethodOptions_IdempotencyLevel.IDEMPOTENT;
 		default: return false;
 	}
@@ -3226,39 +3227,6 @@ function createKyselyGenerator(options) {
 	};
 }
 
-//#endregion
-//#region src/cli/generator/builtin/seed/gql-ingest-processor.ts
-/**
-* Processes TailorDB types to generate GraphQL Ingest metadata
-* @param type - Parsed TailorDB type
-* @param  namespace - Namespace of the type
-* @returns Generated GraphQL Ingest metadata
-*/
-function processGqlIngest(type, namespace) {
-	const dependencies = Array.from(Object.values(type.fields).reduce((set, field) => {
-		if (field.relation?.targetType && field.relation.targetType !== type.name) set.add(field.relation.targetType);
-		return set;
-	}, /* @__PURE__ */ new Set()));
-	const graphql = `mutation Create${type.name}($input: ${type.name}CreateInput!) {
-  create${type.name}(input: $input) {
-    id
-  }
-}
-`;
-	return {
-		name: type.name,
-		namespace,
-		dependencies,
-		mapping: {
-			dataFile: `data/${type.name}.jsonl`,
-			dataFormat: "jsonl",
-			graphqlFile: `graphql/${type.name}.graphql`,
-			mapping: { input: "$" }
-		},
-		graphql
-	};
-}
-
 //#endregion
 //#region src/cli/generator/builtin/seed/idp-user-processor.ts
 /**
@@ -3272,13 +3240,8 @@ function processIdpUser(auth) {
 	return {
 		name: "_User",
 		dependencies: [typeName],
-		mapping: {
-			dataFile: "data/_User.jsonl",
-			dataFormat: "jsonl",
-			graphqlFile: "graphql/_User.graphql",
-			mapping: { input: "$" }
-		},
-		graphql: `mutation CreateUser($input: _CreateUserInput!) {
+		dataFile: "data/_User.jsonl",
+		mutation: `mutation CreateUser($input: _CreateUserInput!) {
   _createUser(input: $input) {
     id
   }
@@ -3427,28 +3390,123 @@ function generateLinesDbSchemaFile(metadata, importPath) {
     `;
 }
 
+//#endregion
+//#region src/cli/generator/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/cli/generator/builtin/seed/index.ts
 const SeedGeneratorID = "@tailor-platform/seed";
 /**
-* Generates the exec.mjs script content (Node.js executable) using gql-ingest Programmatic API
+* Generate the IdP user seed function code
+* @param hasIdpUser - Whether IdP user is included
+* @returns JavaScript code for IdP user seeding function
+*/
+function generateIdpUserSeedFunction(hasIdpUser) {
+	if (!hasIdpUser) return "";
+	return ml`
+    // Seed _User via GraphQL mutation
+    const seedIdpUser = async () => {
+      console.log(styleText("cyan", "  Seeding _User via GraphQL mutation..."));
+      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 _User...\`));
+      const mutation = \`mutation CreateUser($input: _CreateUserInput!) { _createUser(input: $input) { id } }\`;
+      let successCount = 0;
+      let failCount = 0;
+      for (let i = 0; i < rows.length; i++) {
+        try {
+          const response = await fetch(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: \`Bearer \${tokenInfo.accessToken}\` },
+            body: JSON.stringify({ query: mutation, variables: { input: rows[i] } }),
+          });
+          const result = await response.json();
+          if (result.errors) {
+            failCount++;
+            console.error(styleText("red", \`    ✗ Row \${i} in _User failed: \${result.errors[0].message}\`));
+          } else {
+            successCount++;
+          }
+        } catch (error) {
+          failCount++;
+          console.error(styleText("red", \`    ✗ Row \${i} in _User failed: \${error.message}\`));
+        }
+      }
+      console.log(styleText("green", \`    ✓ _User: \${successCount} rows processed\`));
+      if (failCount > 0) {
+        console.error(styleText("red", \`    ✗ _User: \${failCount} rows failed\`));
+      }
+      return { success: failCount === 0 };
+    };
+  `;
+}
+/**
+* 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;
+      }
+    }
+  `;
+}
+/**
+* Generates the exec.mjs script content using testExecScript API for TailorDB types
+* and GraphQL mutation for _User (IdP managed)
 * @param machineUserName - Machine user name for token retrieval
 * @param relativeConfigPath - Config path relative to exec script
-* @param entityDependencies - Entity dependencies mapping
+* @param namespaceConfigs - Namespace configurations with types and dependencies
+* @param hasIdpUser - Whether _User is included
 * @returns exec.mjs file contents
 */
-function generateExecScript(machineUserName, relativeConfigPath, entityDependencies) {
-	const namespaceMap = /* @__PURE__ */ new Map();
-	for (const [type, meta] of Object.entries(entityDependencies)) if (meta.namespace) {
-		if (!namespaceMap.has(meta.namespace)) namespaceMap.set(meta.namespace, []);
-		namespaceMap.get(meta.namespace).push(type);
-	}
+function generateExecScript(machineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser) {
 	return ml`
-    import { GQLIngest } from "@jackchuka/gql-ingest";
+    import { readFileSync } from "node:fs";
     import { join } from "node:path";
     import { parseArgs, styleText } from "node:util";
     import { createInterface } from "node:readline";
-    import { show, getMachineUserToken, truncate } from "@tailor-platform/sdk/cli";
+    import {
+      show,
+      getMachineUserToken,
+      truncate,
+      bundleSeedScript,
+      executeScript,
+      initOperatorClient,
+      loadAccessToken,
+      loadWorkspaceId,
+    } from "@tailor-platform/sdk/cli";
 
     // Parse command-line arguments
     const { values, positionals } = parseArgs({
@@ -3457,6 +3515,7 @@ function generateExecScript(machineUserName, relativeConfigPath, entityDependenc
         "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,
@@ -3471,6 +3530,7 @@ function generateExecScript(machineUserName, relativeConfigPath, entityDependenc
       --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:
@@ -3504,15 +3564,19 @@ function generateExecScript(machineUserName, relativeConfigPath, entityDependenc
     const configDir = import.meta.dirname;
     const configPath = join(configDir, "${relativeConfigPath}");
 
-    console.log(styleText("cyan", "Starting seed data generation..."));
-
     // Entity configuration
     const namespaceEntities = {
-${Array.from(namespaceMap.entries()).map(([namespace, entities]) => {
-		return `      ${namespace}: [\n${entities.map((e) => `        "${e}",`).join("\n")}\n      ]`;
+${namespaceConfigs.map(({ namespace, types }) => {
+		return `      "${namespace}": [\n${types.map((e) => `        "${e}",`).join("\n")}\n      ]`;
+	}).join(",\n")}
+    };
+    const namespaceDeps = {
+${namespaceConfigs.map(({ namespace, dependencies }) => {
+		return `      "${namespace}": {\n${Object.entries(dependencies).map(([type, deps]) => `        "${type}": [${deps.map((d) => `"${d}"`).join(", ")}]`).join(",\n")}\n      }`;
 	}).join(",\n")}
     };
     const entities = Object.values(namespaceEntities).flat();
+    const hasIdpUser = ${String(hasIdpUser)};
 
     // Determine which entities to process
     let entitiesToProcess = null;
@@ -3552,9 +3616,10 @@ ${Array.from(namespaceMap.entries()).map(([namespace, entities]) => {
     if (hasTypes) {
       const requestedTypes = positionals;
       const notFoundTypes = [];
+      const allTypes = hasIdpUser ? [...entities, "_User"] : entities;
 
       entitiesToProcess = requestedTypes.filter((type) => {
-        if (!entities.includes(type)) {
+        if (!allTypes.includes(type)) {
           notFoundTypes.push(type);
           return false;
         }
@@ -3563,7 +3628,7 @@ ${Array.from(namespaceMap.entries()).map(([namespace, entities]) => {
 
       if (notFoundTypes.length > 0) {
         console.error(styleText("red", \`Error: The following types were not found: \${notFoundTypes.join(", ")}\`));
-        console.error(styleText("yellow", \`Available types: \${entities.join(", ")}\`));
+        console.error(styleText("yellow", \`Available types: \${allTypes.join(", ")}\`));
         process.exit(1);
       }
 
@@ -3573,106 +3638,229 @@ ${Array.from(namespaceMap.entries()).map(([namespace, entities]) => {
     // Apply --skip-idp filter
     if (skipIdp) {
       if (entitiesToProcess) {
-        // Filter out _User from already filtered list
         entitiesToProcess = entitiesToProcess.filter((entity) => entity !== "_User");
       } else {
-        // Get all entities except _User
         entitiesToProcess = entities.filter((entity) => entity !== "_User");
       }
-      console.log(styleText("dim", \`Skipping IdP user (_User)\`));
     }
 
     // Truncate tables if requested
-    // Note: --skip-idp only affects seeding, not truncation
     if (values.truncate) {
-      // Prompt user for confirmation
       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", "\\nTruncating tables..."));
+      console.log(styleText("cyan", "Truncating tables..."));
 
       try {
         if (hasNamespace) {
-          // Truncate specific namespace
           await truncate({
             configPath,
+            profile: values.profile,
             namespace: values.namespace,
           });
         } else if (hasTypes) {
-          // Truncate specific types
-          await truncate({
-            configPath,
-            types: entitiesToProcess,
-          });
+          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 {
-          // Truncate all (--skip-idp does not affect truncation)
           await truncate({
             configPath,
+            profile: values.profile,
             all: true,
           });
         }
-        console.log(styleText("green", "Truncate completed.\\n"));
+        console.log(styleText("green", "Truncate completed."));
       } catch (error) {
         console.error(styleText("red", \`Truncate failed: \${error.message}\`));
         process.exit(1);
       }
     }
 
-    // Get application info and endpoint
-    const appInfo = await show({ configPath });
+    console.log(styleText("cyan", "\\nStarting seed data generation..."));
+    if (skipIdp) {
+      console.log(styleText("dim", \`  Skipping IdP user (_User)\`));
+    }
+
+    // Get application info
+    const appInfo = await show({ configPath, profile: values.profile });
     const endpoint = \`\${appInfo.url}/query\`;
+    const authNamespace = appInfo.auth;
 
     // Get machine user token
-    const tokenInfo = await getMachineUserToken({ name: "${machineUserName}", configPath });
-
-    // Initialize GQLIngest client
-    const client = new GQLIngest({
-      endpoint,
-      headers: {
-        Authorization: \`Bearer \${tokenInfo.accessToken}\`,
-      },
+    const tokenInfo = await getMachineUserToken({
+      name: "${machineUserName}",
+      configPath,
+      profile: values.profile,
     });
 
-    // Progress monitoring event handlers
-    client.on("started", (payload) => {
-      console.log(styleText("cyan", \`Processing \${payload.totalEntities} entities...\`));
-    });
+    // 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;
+    };
 
-    client.on("entityStart", (payload) => {
-      console.log(styleText("dim", \`  Processing \${payload.entityName}...\`));
-    });
+    // 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);
+      };
 
-    client.on("entityComplete", (payload) => {
-      const { entityName, metrics: { rowsProcessed } } = payload;
-      console.log(styleText("green", \`  ✓ \${entityName}: \${rowsProcessed} rows processed\`));
-    });
+      for (const type of types) {
+        visit(type);
+      }
+      return result;
+    };
 
-    client.on("rowFailure", (payload) => {
-      console.error(styleText("red", \`  ✗ Row \${payload.rowIndex} in \${payload.entityName} failed: \${payload.error.message}\`));
-    });
+    // 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);
+
+    // 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: {} };
+      }
 
-    // Run ingestion
-    try {
-      let result;
-      if (entitiesToProcess && entitiesToProcess.length > 0) {
-        result = await client.ingestEntities(configDir, entitiesToProcess);
-      } else {
-        result = await client.ingest(configDir);
+      console.log(styleText("cyan", \`  [\${namespace}] Seeding \${typesWithData.length} types via Kysely batch insert...\`));
+
+      // Bundle seed script
+      const bundled = await bundleSeedScript(namespace, typesWithData);
+
+      // Execute seed script
+      const result = await executeScript({
+        client: operatorClient,
+        workspaceId,
+        name: \`seed-\${namespace}.ts\`,
+        code: bundled.bundledCode,
+        arg: JSON.stringify({ data, order: sortedTypes }),
+        invoker: {
+          namespace: authNamespace,
+          machineUserName: "${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}\`));
+          return { success: false, error: message };
+        }
+
+        const processed = parsed.processed || {};
+        for (const [type, count] of Object.entries(processed)) {
+          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: \${errorMessage}\`));
+          return { success: false, error: errorMessage };
+        }
+
+        return { success: true, processed };
+      } else {
+        console.error(styleText("red", \`    ✗ Seed failed: \${result.error}\`));
+        return { success: false, error: result.error };
+      }
+    };
+
+    ${generateIdpUserSeedFunction(hasIdpUser)}
+
+    // 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"));
-        console.log(client.getMetricsSummary());
       } else {
-        console.error(styleText("red", "\\n✗ Seed data generation failed"));
-        console.error(client.getMetricsSummary());
+        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 with error: \${error.message}\`));
+      console.error(styleText("red", \`\\n✗ Seed data generation failed: \${error.message}\`));
       process.exit(1);
     }
 
@@ -3680,45 +3868,38 @@ ${Array.from(namespaceMap.entries()).map(([namespace, entities]) => {
 }
 /**
 * Factory function to create a Seed generator.
-* Combines GraphQL Ingest and lines-db schema generation.
+* Combines Kysely batch insert and lines-db schema generation.
 * @param options - Seed generator options
 * @returns Seed generator
 */
 function createSeedGenerator(options) {
 	return {
 		id: SeedGeneratorID,
-		description: "Generates seed data files (GraphQL Ingest + lines-db schema)",
+		description: "Generates seed data files (Kysely batch insert + GraphQL mutation for _User)",
 		dependencies: ["tailordb"],
 		processType: ({ type, source, namespace }) => {
 			return {
-				gqlIngest: processGqlIngest(type, namespace),
+				typeInfo: processSeedTypeInfo(type, namespace),
 				linesDb: processLinesDb(type, source)
 			};
 		},
 		processTailorDBNamespace: ({ types }) => types,
 		aggregate: ({ input, configPath }) => {
-			const entityDependencies = {};
 			const files = [];
+			const namespaceConfigs = [];
 			for (const nsResult of input.tailordb) {
 				if (!nsResult.types) continue;
 				const outputBaseDir = options.distPath;
-				if (!(outputBaseDir in entityDependencies)) entityDependencies[outputBaseDir] = {};
+				const types = [];
+				const dependencies = {};
 				for (const [_typeName, metadata] of Object.entries(nsResult.types)) {
-					const { gqlIngest, linesDb } = metadata;
-					entityDependencies[outputBaseDir][gqlIngest.name] = {
-						namespace: gqlIngest.namespace,
-						dependencies: gqlIngest.dependencies
-					};
+					const { typeInfo, linesDb } = metadata;
+					types.push(typeInfo.name);
+					dependencies[typeInfo.name] = typeInfo.dependencies;
 					files.push({
-						path: path.join(outputBaseDir, "mappings", `${gqlIngest.name}.json`),
-						content: JSON.stringify(gqlIngest.mapping, null, 2) + "\n"
-					}, {
-						path: path.join(outputBaseDir, gqlIngest.mapping.dataFile),
+						path: path.join(outputBaseDir, typeInfo.dataFile),
 						content: "",
 						skipIfExists: true
-					}, {
-						path: path.join(outputBaseDir, gqlIngest.mapping.graphqlFile),
-						content: gqlIngest.graphql
 					});
 					const schemaOutputPath = path.join(outputBaseDir, "data", `${linesDb.typeName}.schema.ts`);
 					const importPath = path.relative(path.dirname(schemaOutputPath), linesDb.importPath);
@@ -3728,46 +3909,32 @@ function createSeedGenerator(options) {
 						content: generateLinesDbSchemaFile(linesDb, normalizedImportPath)
 					});
 				}
+				namespaceConfigs.push({
+					namespace: nsResult.namespace,
+					types,
+					dependencies
+				});
 			}
-			if (input.auth) {
-				const idpUser = processIdpUser(input.auth);
-				if (idpUser) {
-					const outputBaseDir = options.distPath;
-					if (!(outputBaseDir in entityDependencies)) entityDependencies[outputBaseDir] = {};
-					entityDependencies[outputBaseDir][idpUser.name] = { dependencies: idpUser.dependencies };
-					files.push({
-						path: path.join(outputBaseDir, idpUser.mapping.graphqlFile),
-						content: idpUser.graphql
-					});
-					files.push({
-						path: path.join(outputBaseDir, "mappings", `${idpUser.name}.json`),
-						content: JSON.stringify(idpUser.mapping, null, 2) + "\n"
-					});
-					files.push({
-						path: path.join(outputBaseDir, idpUser.mapping.dataFile),
-						content: "",
-						skipIfExists: true
-					});
-					files.push({
-						path: path.join(outputBaseDir, "data", `${idpUser.name}.schema.ts`),
-						content: generateIdpUserSchemaFile(idpUser.schema.usernameField, idpUser.schema.userTypeName)
-					});
-				}
+			const idpUser = input.auth ? processIdpUser(input.auth) : null;
+			const hasIdpUser = idpUser !== null;
+			if (idpUser) {
+				const outputBaseDir = options.distPath;
+				files.push({
+					path: path.join(outputBaseDir, idpUser.dataFile),
+					content: "",
+					skipIfExists: true
+				});
+				files.push({
+					path: path.join(outputBaseDir, "data", `${idpUser.name}.schema.ts`),
+					content: generateIdpUserSchemaFile(idpUser.schema.usernameField, idpUser.schema.userTypeName)
+				});
 			}
-			for (const [outputDir, dependencies] of Object.entries(entityDependencies)) {
+			if (options.machineUserName) {
+				const relativeConfigPath = path.relative(options.distPath, configPath);
 				files.push({
-					path: path.join(outputDir, "config.yaml"),
-					content: `entityDependencies:
-  ${Object.entries(dependencies).map(([type, deps]) => `${type}: [${deps.dependencies.join(", ")}]`).join("\n  ")}
-`
+					path: path.join(options.distPath, "exec.mjs"),
+					content: generateExecScript(options.machineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser)
 				});
-				if (options.machineUserName) {
-					const relativeConfigPath = path.relative(outputDir, configPath);
-					files.push({
-						path: path.join(outputDir, "exec.mjs"),
-						content: generateExecScript(options.machineUserName, relativeConfigPath, dependencies)
-					});
-				}
 			}
 			return { files };
 		}
@@ -11890,7 +12057,7 @@ async function generate(options) {
 		return;
 	}
 	if (options.init) await handleInitOption(namespacesWithMigrations, options.yes);
-	const { defineApplication: defineApplication$1 } = await import("./application-BdZ8qL7I.mjs");
+	const { defineApplication: defineApplication$1 } = await import("./application-COnpGp0d.mjs");
 	const application = defineApplication$1(config);
 	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
 		logger.info(`Processing namespace: ${styles.bold(namespace)}`);
@@ -13096,5 +13263,5 @@ const updateCommand = defineCommand({
 });
 
 //#endregion
-export { startWorkflow as $, generateCommand as A, trnPrefix as At, getMachineUserToken as B, fetchAll as Bt, resumeCommand as C, isValidMigrationNumber as Ct, truncate as D, formatMigrationDiff as Dt, listWorkflows as E, formatDiffSummary as Et, removeCommand$1 as F, fetchLatestToken as Ft, generateCommand$1 as G, PATScope as Gt, listCommand$5 as H, initOAuth2Client as Ht, listCommand$4 as I, loadAccessToken as It, getExecutorJob as J, deploymentArgs as Jt, triggerCommand as K, commonArgs as Kt, listOAuth2Clients as L, loadWorkspaceId as Lt, show as M, loadConfig as Mt, showCommand as N, apiCall as Nt, truncateCommand as O, hasChanges as Ot, remove as P, apiCommand as Pt, startCommand as Q, getCommand$1 as R, readPlatformConfig as Rt, healthCommand as S, getNextMigrationNumber as St, listCommand$3 as T, reconstructSnapshotFromMigrations as Tt, listMachineUsers as U, initOperatorClient as Ut, tokenCommand as V, fetchUserInfo as Vt, generate$1 as W, readPackageJson as Wt, listExecutorJobs as X, withCommonArgs as Xt, jobsCommand as Y, jsonArgs as Yt, watchExecutorJob as Z, workspaceArgs as Zt, createCommand as _, formatMigrationNumber as _t, listCommand as a, apply as at, listCommand$2 as b, getMigrationFilePath as bt, inviteUser as c, parseMigrationLabelNumber as ct, listCommand$1 as d, INITIAL_SCHEMA_NUMBER as dt, getCommand$2 as et, listWorkspaces as f, MIGRATE_FILE_NAME as ft, deleteWorkspace as g, createSnapshotFromLocalTypes as gt, deleteCommand as h, compareSnapshots as ht, removeUser as i, listWorkflowExecutions as it, logBetaWarning as j, generateUserTypes as jt, generate as k, getNamespacesWithMigrations as kt, restoreCommand as l, DB_TYPES_FILE_NAME as lt, getWorkspace as m, compareLocalTypesWithSnapshot as mt, updateUser as n, executionsCommand as nt, listUsers as o, applyCommand as ot, getCommand as p, SCHEMA_FILE_NAME as pt, triggerExecutor as q, confirmationArgs as qt, removeCommand as r, getWorkflowExecution as rt, inviteCommand as s, MIGRATION_LABEL_KEY as st, updateCommand as t, getWorkflow as tt, restoreWorkspace as u, DIFF_FILE_NAME as ut, createWorkspace as v, getLatestMigrationNumber as vt, resumeWorkflow as w, loadDiff as wt, getAppHealth as x, getMigrationFiles as xt, listApps as y, getMigrationDirPath as yt, getOAuth2Client as z, writePlatformConfig as zt };
-//# sourceMappingURL=update-DZs1loy_.mjs.map
+export { startWorkflow as $, withCommonArgs as $t, generateCommand as A, hasChanges as At, getMachineUserToken as B, loadWorkspaceId as Bt, resumeCommand as C, getMigrationFiles as Ct, truncate as D, reconstructSnapshotFromMigrations as Dt, listWorkflows as E, loadDiff as Et, removeCommand$1 as F, getDistDir as Ft, generateCommand$1 as G, initOAuth2Client as Gt, listCommand$5 as H, writePlatformConfig as Ht, listCommand$4 as I, apiCall as It, getExecutorJob as J, PATScope as Jt, triggerCommand as K, initOperatorClient as Kt, listOAuth2Clients as L, apiCommand as Lt, show as M, trnPrefix as Mt, showCommand as N, generateUserTypes as Nt, truncateCommand as O, formatDiffSummary as Ot, remove as P, loadConfig as Pt, startCommand as Q, jsonArgs as Qt, getCommand$1 as R, fetchLatestToken as Rt, healthCommand as S, getMigrationFilePath as St, listCommand$3 as T, isValidMigrationNumber as Tt, listMachineUsers as U, fetchAll as Ut, tokenCommand as V, readPlatformConfig as Vt, generate$1 as W, fetchUserInfo as Wt, listExecutorJobs as X, confirmationArgs as Xt, jobsCommand as Y, commonArgs as Yt, watchExecutorJob as Z, deploymentArgs as Zt, createCommand as _, compareSnapshots as _t, listCommand as a, apply as at, listCommand$2 as b, getLatestMigrationNumber as bt, inviteUser as c, waitForExecution$1 as ct, listCommand$1 as d, DB_TYPES_FILE_NAME as dt, workspaceArgs as en, getCommand$2 as et, listWorkspaces as f, DIFF_FILE_NAME as ft, deleteWorkspace as g, compareLocalTypesWithSnapshot as gt, deleteCommand as h, SCHEMA_FILE_NAME as ht, removeUser as i, listWorkflowExecutions as it, logBetaWarning as j, getNamespacesWithMigrations as jt, generate as k, formatMigrationDiff as kt, restoreCommand as l, MIGRATION_LABEL_KEY as lt, getWorkspace as m, MIGRATE_FILE_NAME as mt, updateUser as n, executionsCommand as nt, listUsers as o, applyCommand as ot, getCommand as p, INITIAL_SCHEMA_NUMBER as pt, triggerExecutor as q, readPackageJson as qt, removeCommand as r, getWorkflowExecution as rt, inviteCommand as s, executeScript as st, updateCommand as t, getWorkflow as tt, restoreWorkspace as u, parseMigrationLabelNumber as ut, createWorkspace as v, createSnapshotFromLocalTypes as vt, resumeWorkflow as w, getNextMigrationNumber as wt, getAppHealth as x, getMigrationDirPath as xt, listApps as y, formatMigrationNumber as yt, getOAuth2Client as z, loadAccessToken as zt };
+//# sourceMappingURL=update-C877GWkA.mjs.map