@tailor-platform/create-sdk 1.20.0 → 1.22.0

package/templates/generators/src/resolver/getProduct.test.ts

@@ -0,0 +1,92 @@
+import { unauthenticatedTailorUser } from "@tailor-platform/sdk/test";
+import { afterAll, afterEach, beforeAll, describe, expect, test, vi } from "vitest";
+import resolver from "./getProduct";
+
+describe("getProduct resolver", () => {
+  const mockQueryObject = vi.fn();
+  beforeAll(() => {
+    vi.stubGlobal("tailordb", {
+      Client: vi.fn(
+        class {
+          connect = vi.fn();
+          end = vi.fn();
+          queryObject = mockQueryObject;
+        },
+      ),
+    });
+  });
+  afterAll(() => {
+    vi.unstubAllGlobals();
+  });
+  afterEach(() => {
+    mockQueryObject.mockReset();
+  });
+
+  test("returns product with category", async () => {
+    // Select product
+    mockQueryObject.mockResolvedValueOnce({
+      rows: [
+        {
+          id: "product-1",
+          name: "Widget",
+          price: 9.99,
+          status: "ACTIVE",
+          categoryId: "cat-1",
+          description: null,
+          createdAt: new Date(),
+          updatedAt: null,
+        },
+      ],
+    });
+    // Select category
+    mockQueryObject.mockResolvedValueOnce({
+      rows: [{ name: "Gadgets" }],
+    });
+
+    const result = await resolver.body({
+      input: { productId: "product-1" },
+      user: unauthenticatedTailorUser,
+      env: {},
+    });
+
+    expect(result).toEqual({
+      name: "Widget",
+      price: 9.99,
+      status: "ACTIVE",
+      categoryName: "Gadgets",
+    });
+    expect(mockQueryObject).toHaveBeenCalledTimes(2);
+  });
+
+  test("returns product without category", async () => {
+    // Select product (no categoryId)
+    mockQueryObject.mockResolvedValueOnce({
+      rows: [
+        {
+          id: "product-2",
+          name: "Standalone Item",
+          price: 19.99,
+          status: "DRAFT",
+          categoryId: null,
+          description: null,
+          createdAt: new Date(),
+          updatedAt: null,
+        },
+      ],
+    });
+
+    const result = await resolver.body({
+      input: { productId: "product-2" },
+      user: unauthenticatedTailorUser,
+      env: {},
+    });
+
+    expect(result).toEqual({
+      name: "Standalone Item",
+      price: 19.99,
+      status: "DRAFT",
+      categoryName: null,
+    });
+    expect(mockQueryObject).toHaveBeenCalledTimes(1);
+  });
+});

package/templates/generators/src/resolver/getProduct.ts

@@ -0,0 +1,53 @@
+import { createResolver, t } from "@tailor-platform/sdk";
+import { getDB } from "../generated/db";
+
+const resolver = createResolver({
+  name: "getProduct",
+  description: "Retrieves a product by ID with its category",
+  operation: "query",
+  input: {
+    productId: t.uuid(),
+  },
+  body: async (context) => {
+    const db = getDB("main-db");
+
+    const product = await db
+      .selectFrom("Product")
+      .where("id", "=", context.input.productId)
+      .selectAll()
+      .executeTakeFirstOrThrow();
+
+    const result: {
+      name: string;
+      price: number;
+      status: string;
+      categoryName: string | null;
+    } = {
+      name: product.name,
+      price: product.price,
+      status: product.status,
+      categoryName: null,
+    };
+
+    if (product.categoryId) {
+      const category = await db
+        .selectFrom("Category")
+        .where("id", "=", product.categoryId)
+        .select("name")
+        .executeTakeFirst();
+      if (category) {
+        result.categoryName = category.name;
+      }
+    }
+
+    return result;
+  },
+  output: t.object({
+    name: t.string(),
+    price: t.float(),
+    status: t.string(),
+    categoryName: t.string({ optional: true }),
+  }),
+});
+
+export default resolver;

package/templates/generators/src/seed/data/Category.schema.ts

@@ -0,0 +1,23 @@
+import { t } from "@tailor-platform/sdk";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { defineSchema } from "@toiroakr/lines-db";
+import { category } from "../../db/category";
+
+const schemaType = t.object({
+  ...category.pickFields(["id"], { optional: true }),
+  ...category.omitFields(["id"]),
+});
+
+const hook = createTailorDBHook(category);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    foreignKeys: [
+      {"column":"parentCategoryId","references":{"table":"Category","column":"id"}},
+    ],
+    indexes: [
+      {"name":"category_slug_unique_idx","columns":["slug"],"unique":true},
+    ],
+  }
+);

package/templates/generators/src/seed/data/Order.schema.ts

@@ -0,0 +1,21 @@
+import { t } from "@tailor-platform/sdk";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { defineSchema } from "@toiroakr/lines-db";
+import { order } from "../../db/order";
+
+const schemaType = t.object({
+  ...order.pickFields(["id","createdAt"], { optional: true }),
+  ...order.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(order);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    foreignKeys: [
+      {"column":"productId","references":{"table":"Product","column":"id"}},
+      {"column":"userId","references":{"table":"User","column":"id"}},
+    ],
+  }
+);

package/templates/generators/src/seed/data/Product.schema.ts

@@ -0,0 +1,23 @@
+import { t } from "@tailor-platform/sdk";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { defineSchema } from "@toiroakr/lines-db";
+import { product } from "../../db/product";
+
+const schemaType = t.object({
+  ...product.pickFields(["id","createdAt"], { optional: true }),
+  ...product.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(product);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    foreignKeys: [
+      {"column":"categoryId","references":{"table":"Category","column":"id"}},
+    ],
+    indexes: [
+      {"name":"idx_status_categoryId","columns":["status","categoryId"],"unique":false},
+    ],
+  }
+);

package/templates/generators/src/seed/data/User.schema.ts

@@ -0,0 +1,20 @@
+import { t } from "@tailor-platform/sdk";
+import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+import { defineSchema } from "@toiroakr/lines-db";
+import { user } from "../../db/user";
+
+const schemaType = t.object({
+  ...user.pickFields(["id","createdAt"], { optional: true }),
+  ...user.omitFields(["id","createdAt"]),
+});
+
+const hook = createTailorDBHook(user);
+
+export const schema = defineSchema(
+  createStandardSchema(schemaType, hook),
+  {
+    indexes: [
+      {"name":"user_email_unique_idx","columns":["email"],"unique":true},
+    ],
+  }
+);

package/templates/generators/src/seed/exec.mjs

@@ -0,0 +1,419 @@
+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, "../../tailor.config.ts");
+
+// Determine machine user name (CLI argument takes precedence over config default)
+const defaultMachineUser = "admin";
+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 = {
+  "main-db": [
+    "Category",
+    "Order",
+    "Product",
+    "User",
+  ]
+};
+const namespaceDeps = {
+  "main-db": {
+    "Category": [],
+    "Order": ["Product", "User"],
+    "Product": ["Category"],
+    "User": []
+  }
+};
+const entities = Object.values(namespaceEntities).flat();
+const hasIdpUser = false;
+
+// 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);
+
+
+
+// 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);
+  }
+
+  
+
+  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 };
+};
+
+
+
+// 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;
+    }
+  }
+
+  
+
+  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);
+}

package/templates/generators/tailor.config.ts

@@ -0,0 +1,36 @@
+import { defineAuth, defineConfig, defineIdp, definePlugins, t } from "@tailor-platform/sdk";
+import { enumConstantsPlugin } from "@tailor-platform/sdk/plugin/enum-constants";
+import { fileUtilsPlugin } from "@tailor-platform/sdk/plugin/file-utils";
+import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";
+import { seedPlugin } from "@tailor-platform/sdk/plugin/seed";
+
+const idp = defineIdp("main-idp", {
+  authorization: "loggedIn",
+  clients: ["default-idp-client"],
+});
+
+export default defineConfig({
+  name: "generators",
+  auth: defineAuth("main-auth", {
+    machineUserAttributes: {
+      role: t.string(),
+    },
+    machineUsers: {
+      admin: {
+        attributes: {
+          role: "admin",
+        },
+      },
+    },
+  }),
+  idp: [idp],
+  db: { "main-db": { files: ["./src/db/*.ts"] } },
+  resolver: { "main-resolver": { files: ["./src/resolver/*.ts"] } },
+});
+
+export const plugins = definePlugins(
+  kyselyTypePlugin({ distPath: "./src/generated/db.ts" }),
+  enumConstantsPlugin({ distPath: "./src/generated/enums.ts" }),
+  fileUtilsPlugin({ distPath: "./src/generated/files.ts" }),
+  seedPlugin({ distPath: "./src/seed", machineUserName: "admin" }),
+);