@specverse/engines 6.11.2 → 6.16.0

package/dist/libs/instance-factories/services/templates/postgres-native/client-generator.js

@@ -0,0 +1,165 @@
+function generatePgClient(_context) {
+  return `/**
+ * Postgres native (pg) \u2014 singleton pool + helpers.
+ *
+ * Picks up POSTGRES_URL or DATABASE_URL from the environment. The pool is
+ * lazily initialised on first use and reused across requests; \`disconnect\`
+ * is exposed for graceful-shutdown wiring. \`withTx\` runs a callback in a
+ * single connection inside BEGIN/COMMIT (rolled back on throw).
+ */
+import { Pool, type PoolClient, type QueryResult, type QueryResultRow } from 'pg';
+
+const connectionString =
+  process.env.POSTGRES_URL ||
+  process.env.DATABASE_URL ||
+  'postgres://postgres:postgres@localhost:5432/specverse';
+
+let pool: Pool | null = null;
+
+export function getPool(): Pool {
+  if (pool) return pool;
+  pool = new Pool({ connectionString });
+  return pool;
+}
+
+/** Run a parameterised query against the pool.
+ *  T defaults to QueryResultRow so callers can pass a row interface. */
+export async function query<T extends QueryResultRow = QueryResultRow>(
+  text: string,
+  params: ReadonlyArray<unknown> = [],
+): Promise<QueryResult<T>> {
+  return getPool().query<T>(text, params as unknown[]);
+}
+
+/** Run a callback inside a transaction. The callback receives a dedicated
+ *  client; commit on resolve, rollback on throw. */
+export async function withTx<T>(
+  fn: (client: PoolClient) => Promise<T>,
+): Promise<T> {
+  const client = await getPool().connect();
+  try {
+    await client.query('BEGIN');
+    const result = await fn(client);
+    await client.query('COMMIT');
+    return result;
+  } catch (err) {
+    await client.query('ROLLBACK');
+    throw err;
+  } finally {
+    client.release();
+  }
+}
+
+/** Build a comma-separated list of \`"col"\` from an object's keys, plus
+ *  matching positional placeholders \`$1, $2, ...\`. Quoted to preserve
+ *  case-sensitive identifiers (camelCase columns work without folding). */
+function buildPositionals(keys: string[], offset = 0): string {
+  return keys.map((_k, i) => '$' + (i + 1 + offset)).join(', ');
+}
+function quoteCols(keys: string[]): string {
+  return keys.map((k) => '"' + k.replace(/"/g, '""') + '"').join(', ');
+}
+
+/** INSERT a record into \`table\` and return the inserted row (with any
+ *  database-supplied defaults like generated id / createdAt populated). */
+export async function insertOne<T extends QueryResultRow = QueryResultRow>(
+  table: string,
+  record: Record<string, unknown>,
+): Promise<T> {
+  const keys = Object.keys(record);
+  const values = keys.map((k) => record[k]);
+  const sql = keys.length === 0
+    ? \`INSERT INTO "\${table}" DEFAULT VALUES RETURNING *\`
+    : \`INSERT INTO "\${table}" (\${quoteCols(keys)}) VALUES (\${buildPositionals(keys)}) RETURNING *\`;
+  const result = await query<T>(sql, values);
+  return result.rows[0] as T;
+}
+
+/** Bulk-insert many records into \`table\` in one round trip. Returns the
+ *  inserted rows. All records must share the same shape. */
+export async function insertMany<T extends QueryResultRow = QueryResultRow>(
+  table: string,
+  records: ReadonlyArray<Record<string, unknown>>,
+): Promise<T[]> {
+  if (records.length === 0) return [];
+  const firstKeys = Object.keys(records[0]!);
+  const valuesClauses: string[] = [];
+  const flatValues: unknown[] = [];
+  for (let i = 0; i < records.length; i++) {
+    const row = records[i] as Record<string, unknown>;
+    const placeholders = firstKeys.map((_k, j) => '$' + (i * firstKeys.length + j + 1)).join(', ');
+    valuesClauses.push('(' + placeholders + ')');
+    for (const k of firstKeys) flatValues.push(row[k]);
+  }
+  const sql = \`INSERT INTO "\${table}" (\${quoteCols(firstKeys)}) VALUES \${valuesClauses.join(', ')} RETURNING *\`;
+  const result = await query<T>(sql, flatValues);
+  return result.rows;
+}
+
+/** SELECT a single row by a field equality. Returns null if not found. */
+export async function findOneByField<T extends QueryResultRow = QueryResultRow>(
+  table: string,
+  field: string,
+  value: unknown,
+): Promise<T | null> {
+  const sql = \`SELECT * FROM "\${table}" WHERE "\${field.replace(/"/g, '""')}" = $1 LIMIT 1\`;
+  const result = await query<T>(sql, [value]);
+  return result.rows[0] ?? null;
+}
+
+/** SELECT a single row matching all (field, value) pairs (AND-ed). */
+export async function findOneByFields<T extends QueryResultRow = QueryResultRow>(
+  table: string,
+  fields: Record<string, unknown>,
+): Promise<T | null> {
+  const keys = Object.keys(fields);
+  if (keys.length === 0) {
+    const result = await query<T>(\`SELECT * FROM "\${table}" LIMIT 1\`);
+    return result.rows[0] ?? null;
+  }
+  const where = keys.map((k, i) => '"' + k.replace(/"/g, '""') + '" = $' + (i + 1)).join(' AND ');
+  const sql = \`SELECT * FROM "\${table}" WHERE \${where} LIMIT 1\`;
+  const result = await query<T>(sql, keys.map((k) => fields[k]));
+  return result.rows[0] ?? null;
+}
+
+/** SELECT all rows from a table \u2014 equivalent to a Mongo
+ *  \`collection.find({}).toArray()\` for the bulk-fan-out auto-create
+ *  convention. */
+export async function findAll<T extends QueryResultRow = QueryResultRow>(
+  table: string,
+): Promise<T[]> {
+  const result = await query<T>(\`SELECT * FROM "\${table}"\`);
+  return result.rows;
+}
+
+/** UPDATE columns of the row identified by id. Quotes column names so
+ *  camelCase identifiers survive postgres' default lower-case folding. */
+export async function updateOneById(
+  table: string,
+  id: unknown,
+  patch: Record<string, unknown>,
+): Promise<void> {
+  const keys = Object.keys(patch);
+  if (keys.length === 0) return;
+  const setClause = keys.map((k, i) => '"' + k.replace(/"/g, '""') + '" = $' + (i + 1)).join(', ');
+  const sql = \`UPDATE "\${table}" SET \${setClause} WHERE "id" = $\${keys.length + 1}\`;
+  await query(sql, [...keys.map((k) => patch[k]), id]);
+}
+
+/** DELETE the row identified by id. */
+export async function deleteOneById(table: string, id: unknown): Promise<void> {
+  await query(\`DELETE FROM "\${table}" WHERE "id" = $1\`, [id]);
+}
+
+export async function disconnect(): Promise<void> {
+  if (pool) {
+    await pool.end();
+    pool = null;
+  }
+}
+`;
+}
+export {
+  generatePgClient as default
+};

package/dist/libs/instance-factories/services/templates/postgres-native/controller-generator.js

@@ -0,0 +1,300 @@
+import { buildTransitionMap, isAutoField } from "@specverse/types/spec-rules";
+function generatePgNativeController(context) {
+  const { controller, model, models } = context;
+  if (!controller) throw new Error("Controller is required in template context");
+  if (!model) throw new Error("Model is required for controller generation");
+  const controllerName = controller.name;
+  const modelName = model.name;
+  const modelVar = lowerFirst(modelName);
+  const table = tableName(model);
+  const curedOps = controller.cured || {};
+  const modelRegistry = {};
+  if (Array.isArray(models)) {
+    for (const m of models) if (m?.name) modelRegistry[m.name] = m;
+  } else if (models && typeof models === "object") {
+    Object.assign(modelRegistry, models);
+  }
+  const customActions = generateCustomActions(controller, modelRegistry);
+  const validate = generateValidateMethod(model, modelName);
+  const create = curedOps.create ? generateCreateMethod(modelName, modelVar) : "";
+  const retrieve = curedOps.retrieve ? generateRetrieveMethod(modelName, modelVar) : "";
+  const update = curedOps.update ? generateUpdateMethod(modelName, modelVar) : "";
+  const evolve = curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar) : "";
+  const del = curedOps.delete ? generateDeleteMethod(modelName, modelVar) : "";
+  const hasEventPublishing = curedOps.create || curedOps.update || curedOps.evolve || curedOps.delete;
+  const helperImports = [
+    "insertOne",
+    "findOneByField",
+    "findAll",
+    "updateOneById",
+    "deleteOneById",
+    "query",
+    customActions.code.includes("findOneByFields(") ? "findOneByFields" : "",
+    customActions.code.includes("insertMany(") ? "insertMany" : ""
+  ].filter(Boolean).join(", ");
+  return `/**
+ * ${controllerName}
+ * Model-specific business logic for ${modelName} (PostgreSQL native driver)
+ * ${controller.description || ""}
+ */
+import { ${helperImports} } from '../db/pgClient.js';
+${hasEventPublishing || customActions.needsAiBehaviors ? `import { eventBus } from '../events/eventBus.js';` : ""}
+${customActions.needsAiBehaviors ? `import * as aiBehaviors from '../behaviors/${controllerName}.ai.js';` : ""}
+
+const TABLE_NAME = '${table}';
+
+export class ${controllerName} {
+${validate}
+${create}
+${retrieve}
+${update}
+${evolve}
+${del}
+${customActions.code}
+}
+
+export const ${modelVar}Controller = new ${controllerName}();
+export default ${modelVar}Controller;
+`;
+}
+function lowerFirst(s) {
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}
+function tableName(model) {
+  if (model?.storage?.table) return String(model.storage.table);
+  return model.name.toLowerCase() + "s";
+}
+function generateValidateMethod(model, modelName) {
+  return `
+  /**
+   * Validate ${modelName} data \u2014 runs before create / update / evolve.
+   */
+  public validate(
+    _data: any,
+    _context: { operation: 'create' | 'update' | 'evolve' }
+  ): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+${generateValidationLogic(model)}
+    return { valid: errors.length === 0, errors };
+  }
+`;
+}
+function generateValidationLogic(model) {
+  if (!model.attributes) return "    // No validation rules defined";
+  const attrList = Array.isArray(model.attributes) ? model.attributes.map((a) => [a.name, a]) : Object.entries(model.attributes);
+  const out = [];
+  attrList.forEach(([name, attr]) => {
+    if (attr.required && !isAutoField(name, attr)) {
+      out.push(`    if (_context.operation === 'create' && !_data.${name}) errors.push('${name} is required');`);
+    }
+    if (attr.type === "String" || attr.type === "string") {
+      if (attr.min) out.push(`    if (_data.${name} && _data.${name}.length < ${attr.min}) errors.push('${name} must be at least ${attr.min} characters');`);
+      if (attr.max) out.push(`    if (_data.${name} && _data.${name}.length > ${attr.max}) errors.push('${name} must be at most ${attr.max} characters');`);
+    }
+    if (attr.values && Array.isArray(attr.values)) {
+      const values = attr.values.map((v) => `'${v}'`).join(", ");
+      out.push(`    if (_data.${name} && ![${values}].includes(_data.${name})) errors.push('${name} must be one of: ${attr.values.join(", ")}');`);
+    }
+    if (attr.format === "email") {
+      out.push(`    if (_data.${name} && !/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(_data.${name})) errors.push('${name} must be a valid email address');`);
+    }
+  });
+  return out.join("\n") || "    // No validation rules defined";
+}
+function generateCreateMethod(modelName, modelVar) {
+  return `
+  /**
+   * Create a new ${modelName}.
+   */
+  public async create(data: any): Promise<any> {
+    const validation = this.validate(data, { operation: 'create' });
+    if (!validation.valid) throw new Error(\`Validation failed: \${validation.errors.join(', ')}\`);
+
+    const ${modelVar} = await insertOne(TABLE_NAME, { ...data });
+
+    await eventBus.publish('${modelName}Created', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
+    return ${modelVar};
+  }
+`;
+}
+function generateRetrieveMethod(modelName, _modelVar) {
+  return `
+  /**
+   * Retrieve ${modelName} by id. Returns null when not found.
+   */
+  public async retrieve(id: string): Promise<any | null> {
+    return await findOneByField(TABLE_NAME, 'id', id);
+  }
+
+  /**
+   * Retrieve a page of ${modelName}s.
+   */
+  public async retrieveAll(options: { skip?: number; take?: number } = {}): Promise<any[]> {
+    if (!options.skip && !options.take) {
+      return await findAll(TABLE_NAME);
+    }
+    const limit = options.take ?? 100;
+    const offset = options.skip ?? 0;
+    const result = await query(\`SELECT * FROM "\${TABLE_NAME}" LIMIT $1 OFFSET $2\`, [limit, offset]);
+    return result.rows;
+  }
+`;
+}
+function generateUpdateMethod(modelName, modelVar) {
+  return `
+  /**
+   * Update ${modelName}.
+   */
+  public async update(id: string, data: any): Promise<any> {
+    const validation = this.validate(data, { operation: 'update' });
+    if (!validation.valid) throw new Error(\`Validation failed: \${validation.errors.join(', ')}\`);
+
+    // Strip nested objects + id \u2014 only scalar fields are written.
+    const updateData: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key === 'id') continue;
+      if (Array.isArray(value)) continue;
+      if (value !== null && typeof value === 'object' && !(value instanceof Date)) continue;
+      updateData[key] = value;
+    }
+
+    await updateOneById(TABLE_NAME, id, updateData);
+    const ${modelVar} = await findOneByField(TABLE_NAME, 'id', id);
+    if (!${modelVar}) throw new Error('${modelName} not found after update');
+
+    await eventBus.publish('${modelName}Updated', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
+    return ${modelVar};
+  }
+`;
+}
+function generateEvolveMethod(model, modelName, modelVar) {
+  const lifecycles = Array.isArray(model.lifecycles) ? model.lifecycles : model.lifecycles ? Object.entries(model.lifecycles).map(([name, lc]) => ({ name, ...lc })) : [];
+  const lifecycle = lifecycles[0];
+  const lifecycleName = lifecycle?.name || "status";
+  const validTransitions = lifecycle ? buildTransitionMap(lifecycle) : {};
+  const states = lifecycle?.states && lifecycle.states.length > 0 ? lifecycle.states.map((s) => typeof s === "string" ? s : s.name) : Array.from(/* @__PURE__ */ new Set([
+    ...Object.keys(validTransitions),
+    ...Object.values(validTransitions).flat()
+  ]));
+  return `
+  /**
+   * Evolve ${modelName} through lifecycle "${lifecycleName}"
+   * States: ${states.join(" \u2192 ") || "(none declared)"}
+   */
+  public async evolve(id: string, data: any): Promise<any> {
+    const current = await findOneByField(TABLE_NAME, 'id', id);
+    if (!current) throw new Error('${modelName} not found');
+
+    const targetLifecycle = data?.lifecycleName || '${lifecycleName}';
+    const targetState = data?.toState ?? data?.state ?? data?.[targetLifecycle];
+    if (!targetState) throw new Error('evolve requires toState (or ${lifecycleName}) in the request body');
+
+    ${states.length > 0 ? `
+    const currentState = (current as any)[targetLifecycle];
+    const validTransitions: Record<string, string[]> = ${JSON.stringify(validTransitions)};
+    const allowed = validTransitions[currentState] || [];
+    if (!allowed.includes(targetState)) {
+      throw new Error(\`Invalid transition: \${currentState} \u2192 \${targetState}. Allowed: \${allowed.join(', ') || 'none'}\`);
+    }
+    ` : ""}
+
+    await updateOneById(TABLE_NAME, id, { [targetLifecycle]: targetState });
+    const ${modelVar} = await findOneByField(TABLE_NAME, 'id', id);
+    if (!${modelVar}) throw new Error('${modelName} not found after evolve');
+
+    await eventBus.publish('${modelName}Evolved', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
+    return ${modelVar};
+  }
+`;
+}
+function generateDeleteMethod(modelName, modelVar) {
+  return `
+  /**
+   * Delete ${modelName}.
+   */
+  public async delete(id: string): Promise<void> {
+    const ${modelVar} = await findOneByField(TABLE_NAME, 'id', id);
+    await deleteOneById(TABLE_NAME, id);
+    if (${modelVar}) {
+      await eventBus.publish('${modelName}Deleted', { ...${modelVar}, timestamp: new Date().toISOString() } as any);
+    }
+  }
+`;
+}
+import { matchPgStep } from "./step-conventions.js";
+function generateCustomActions(controller, modelRegistry = {}) {
+  if (!controller.actions || Object.keys(controller.actions).length === 0) {
+    return { code: "", needsAiBehaviors: false };
+  }
+  const CRUD_NAMES = /* @__PURE__ */ new Set(["create", "retrieve", "retrieveAll", "update", "evolve", "delete", "validate"]);
+  const modelName = controller.model || (controller.name || "").replace(/Controller$/, "") || "Model";
+  const tableNameLocal = modelName.toLowerCase() + "s";
+  const out = [];
+  let needsAiBehaviors = false;
+  for (const [actionName, action] of Object.entries(controller.actions)) {
+    if (CRUD_NAMES.has(actionName)) {
+      console.warn(
+        `\u26A0\uFE0F  ${controller.name || "Controller"}.${actionName} \u2014 behaviour-derived action collides with the auto-generated CURVED \`${actionName}\` op. Dropped to avoid TS2393 duplicate-implementation. Rename the behaviour (e.g. \`${actionName}Soft\` / \`hardDelete\`) if you need the custom logic.`
+      );
+      continue;
+    }
+    const steps = Array.isArray(action.steps) ? action.steps : [];
+    const stepsHeader = steps.length > 0 ? steps.map((s) => `   *   - ${typeof s === "string" ? s : s.action || JSON.stringify(s)}`).join("\n") : "   *   (no spec steps declared)";
+    const declaredVars = /* @__PURE__ */ new Set();
+    const stepBodies = [];
+    let usesArgs = false;
+    let actionRefersToAi = false;
+    steps.forEach((rawStep, i) => {
+      const stepText = typeof rawStep === "string" ? rawStep : rawStep?.step || rawStep?.action;
+      if (typeof stepText !== "string") {
+        stepBodies.push(`    // Step ${i + 1}: (non-string step ignored)`);
+        return;
+      }
+      const ctx = {
+        modelName,
+        tableName: tableNameLocal,
+        serviceName: controller.name || "Controller",
+        operationName: actionName,
+        stepNum: i + 1,
+        parameterNames: Object.keys(action.parameters || {}),
+        declaredVars,
+        models: modelRegistry
+      };
+      const result = matchPgStep(stepText, ctx);
+      stepBodies.push(result.call);
+      if (/\bargs\./.test(result.call)) usesArgs = true;
+      if (!result.matched) actionRefersToAi = true;
+    });
+    if (actionRefersToAi) needsAiBehaviors = true;
+    const argsParam = usesArgs ? "args: any = {}" : "_args: any = {}";
+    let combined = stepBodies.join("\n\n");
+    const stepResultRe = /const\s+(step\d+Result)\s*=/g;
+    let mres;
+    const declared = [];
+    while ((mres = stepResultRe.exec(combined)) !== null) declared.push(mres[1]);
+    for (const name of declared) {
+      const refCount = (combined.match(new RegExp(`\\b${name}\\b`, "g")) || []).length;
+      if (refCount <= 1) {
+        combined = combined.replace(new RegExp(`const\\s+${name}\\s*=\\s*`), "");
+      }
+    }
+    const body = steps.length > 0 ? combined + `
+    return { success: true };` : `    throw new Error('${controller.name || "Controller"}.${actionName} is not implemented');`;
+    out.push(`
+  /**
+   * ${actionName}
+   * ${action.description || ""}
+   *
+   * Spec steps:
+${stepsHeader}
+   */
+  public async ${actionName}(${argsParam}): Promise<any> {
+${body}
+  }
+`);
+  }
+  return { code: out.join("\n"), needsAiBehaviors };
+}
+export {
+  generatePgNativeController as default
+};

package/dist/libs/instance-factories/services/templates/postgres-native/ddl-generator.js

@@ -0,0 +1,169 @@
+function generatePgSchemaSql(context) {
+  const { spec, models } = context;
+  const allModels = [];
+  if (Array.isArray(models) && models.length > 0) {
+    for (const m of models) if (m?.name) allModels.push([m.name, m]);
+  } else if (spec?.components) {
+    const components = Array.isArray(spec.components) ? spec.components : Object.values(spec.components);
+    for (const comp of components) {
+      const ms = comp?.models;
+      if (!ms) continue;
+      const entries = Array.isArray(ms) ? ms.map((m) => [m.name, m]) : Object.entries(ms);
+      for (const [name, m] of entries) {
+        if (name) allModels.push([name, m]);
+      }
+    }
+  }
+  const banner = `-- ============================================================
+-- ${spec?.metadata?.component || "Application"} \u2014 schema.sql
+-- Generated by @specverse/engines (postgres-native).
+-- Run via: psql "$POSTGRES_URL" -f src/db/schema.sql
+-- Re-runnable: every statement is IF NOT EXISTS / idempotent.
+-- ============================================================
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";  -- for gen_random_uuid()
+`;
+  if (allModels.length === 0) {
+    return banner + "\n-- No models declared. (Add one to your spec to populate this file.)\n";
+  }
+  const tableBlocks = allModels.map(([name, model]) => generateTable(name, model));
+  return banner + "\n" + tableBlocks.join("\n\n") + "\n";
+}
+function generateTable(modelName, model) {
+  const table = model?.storage?.table || modelName.toLowerCase() + "s";
+  const attrs = model.attributes;
+  if (!attrs) {
+    return `-- ${modelName}
+CREATE TABLE IF NOT EXISTS "${table}" (
+  id TEXT PRIMARY KEY
+);`;
+  }
+  const list = Array.isArray(attrs) ? attrs.map((a) => [a.name, a]) : Object.entries(attrs);
+  const columns = [];
+  const indexes = [];
+  let hasIdColumn = false;
+  for (const [colName, attr] of list) {
+    if (!colName) continue;
+    const { sql, isPk, isUnique } = columnDef(colName, attr, modelName);
+    if (isPk) hasIdColumn = true;
+    columns.push("  " + sql);
+    if (isUnique && !isPk) {
+      indexes.push(
+        `CREATE UNIQUE INDEX IF NOT EXISTS "${table}_${colName}_uq" ON "${table}" ("${colName}");`
+      );
+    } else if (colName.endsWith("Id") && colName !== "id") {
+      indexes.push(
+        `CREATE INDEX IF NOT EXISTS "${table}_${colName}_idx" ON "${table}" ("${colName}");`
+      );
+    }
+  }
+  if (!hasIdColumn) {
+    columns.unshift('  "id" TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text');
+  }
+  const declaredNames = new Set(list.map(([n]) => n));
+  if (!declaredNames.has("createdAt")) {
+    columns.push('  "createdAt" TIMESTAMPTZ NOT NULL DEFAULT NOW()');
+  }
+  if (!declaredNames.has("updatedAt")) {
+    columns.push('  "updatedAt" TIMESTAMPTZ NOT NULL DEFAULT NOW()');
+  }
+  const lifecycles = Array.isArray(model.lifecycles) ? model.lifecycles : model.lifecycles ? Object.entries(model.lifecycles).map(([name, lc]) => ({ name, ...lc })) : [];
+  for (const lc of lifecycles) {
+    const lcName = lc?.name;
+    if (!lcName || declaredNames.has(lcName)) continue;
+    const initial = deriveInitialState(lc);
+    const defaultClause = initial ? ` DEFAULT '${initial.replace(/'/g, "''")}'` : "";
+    columns.push(`  "${lcName}" TEXT NOT NULL${defaultClause}`);
+  }
+  const indexBlock = indexes.length > 0 ? "\n\n" + indexes.join("\n") : "";
+  return `-- ${modelName}
+CREATE TABLE IF NOT EXISTS "${table}" (
+${columns.join(",\n")}
+);${indexBlock}`;
+}
+function columnDef(name, attr, _modelName) {
+  const required = !!attr.required;
+  const unique = !!attr.unique;
+  const type = (attr.type || "String").toLowerCase();
+  const isIdColumn = name === "id";
+  if (isIdColumn) {
+    if (type === "uuid") {
+      return { sql: `"id" UUID PRIMARY KEY DEFAULT gen_random_uuid()`, isPk: true, isUnique: true };
+    }
+    return { sql: `"id" TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text`, isPk: true, isUnique: true };
+  }
+  let sqlType;
+  switch (type) {
+    case "integer":
+    case "int":
+      sqlType = "INTEGER";
+      break;
+    case "bigint":
+      sqlType = "BIGINT";
+      break;
+    case "float":
+    case "number":
+    case "double":
+      sqlType = "DOUBLE PRECISION";
+      break;
+    case "boolean":
+    case "bool":
+      sqlType = "BOOLEAN";
+      break;
+    case "datetime":
+    case "date":
+    case "timestamp":
+      sqlType = "TIMESTAMPTZ";
+      break;
+    case "uuid":
+      sqlType = "UUID";
+      break;
+    case "json":
+    case "jsonb":
+      sqlType = "JSONB";
+      break;
+    default:
+      sqlType = "TEXT";
+  }
+  const nullness = required ? " NOT NULL" : "";
+  const uniqueClause = unique ? " UNIQUE" : "";
+  const defaultClause = formatColumnDefault(attr.default, type);
+  return {
+    sql: `"${name}" ${sqlType}${nullness}${uniqueClause}${defaultClause}`,
+    isPk: false,
+    isUnique: unique
+  };
+}
+function deriveInitialState(lc) {
+  if (!lc) return null;
+  if (typeof lc.initial === "string") return lc.initial;
+  if (Array.isArray(lc.states) && lc.states.length > 0) {
+    const first = lc.states[0];
+    return typeof first === "string" ? first : first?.name ?? null;
+  }
+  if (typeof lc.flow === "string") {
+    const head = lc.flow.split(/\s*->\s*/)[0]?.trim();
+    return head || null;
+  }
+  if (lc.transitions && typeof lc.transitions === "object") {
+    const first = Object.values(lc.transitions)[0];
+    if (typeof first === "string") return first.split(/\s*->\s*/)[0]?.trim() || null;
+  }
+  return null;
+}
+function formatColumnDefault(value, type) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "boolean") return ` DEFAULT ${value}`;
+  if (typeof value === "number") return ` DEFAULT ${value}`;
+  if (typeof value === "string") {
+    if (/^-?\d+(\.\d+)?$/.test(value)) return ` DEFAULT ${value}`;
+    if (value === "true" || value === "false") return ` DEFAULT ${value}`;
+    if (value === "now" && (type === "datetime" || type === "date" || type === "timestamp")) {
+      return ` DEFAULT NOW()`;
+    }
+    return ` DEFAULT '${value.replace(/'/g, "''")}'`;
+  }
+  return "";
+}
+export {
+  generatePgSchemaSql as default
+};