postgresdk 0.6.10 → 0.6.14

package/dist/cli.js

@@ -470,6 +470,675 @@ var require_config = __commonJS(() => {
   })();
 });
 
+// src/utils.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function writeFiles(files) {
+  for (const f of files) {
+    await mkdir(dirname(f.path), { recursive: true });
+    await writeFile(f.path, f.content, "utf-8");
+  }
+}
+async function ensureDirs(dirs) {
+  for (const d of dirs)
+    await mkdir(d, { recursive: true });
+}
+var pascal = (s) => s.split(/[_\s-]+/).map((w) => w?.[0] ? w[0].toUpperCase() + w.slice(1) : "").join("");
+var init_utils = () => {};
+
+// src/emit-sdk-contract.ts
+var exports_emit_sdk_contract = {};
+__export(exports_emit_sdk_contract, {
+  generateUnifiedContractMarkdown: () => generateUnifiedContractMarkdown,
+  generateUnifiedContract: () => generateUnifiedContract,
+  emitUnifiedContract: () => emitUnifiedContract
+});
+function generateUnifiedContract(model, config) {
+  const resources = [];
+  const relationships = [];
+  const tables = model && model.tables ? Object.values(model.tables) : [];
+  if (process.env.SDK_DEBUG) {
+    console.log(`[SDK Contract] Processing ${tables.length} tables`);
+  }
+  for (const table of tables) {
+    resources.push(generateResourceWithSDK(table, model));
+    for (const fk of table.fks) {
+      relationships.push({
+        from: table.name,
+        to: fk.toTable,
+        type: "many-to-one",
+        description: `Each ${table.name} belongs to one ${fk.toTable}`
+      });
+    }
+  }
+  const contract = {
+    version: "2.0.0",
+    generatedAt: new Date().toISOString(),
+    description: "Unified API and SDK contract - your one-stop reference for all operations",
+    sdk: {
+      initialization: generateSDKInitExamples(),
+      authentication: generateSDKAuthExamples(config.auth)
+    },
+    resources,
+    relationships
+  };
+  return contract;
+}
+function generateSDKInitExamples() {
+  return [
+    {
+      description: "Basic initialization",
+      code: `import { SDK } from './client';
+
+const sdk = new SDK({
+  baseUrl: 'http://localhost:3000'
+});`
+    },
+    {
+      description: "With authentication",
+      code: `import { SDK } from './client';
+
+const sdk = new SDK({
+  baseUrl: 'https://api.example.com',
+  auth: {
+    apiKey: process.env.API_KEY
+  }
+});`
+    },
+    {
+      description: "With custom fetch (for Node.js < 18)",
+      code: `import { SDK } from './client';
+import fetch from 'node-fetch';
+
+const sdk = new SDK({
+  baseUrl: 'https://api.example.com',
+  fetch: fetch as any
+});`
+    }
+  ];
+}
+function generateSDKAuthExamples(auth) {
+  const examples = [];
+  if (!auth || auth.strategy === "none" || !auth.strategy) {
+    examples.push({
+      strategy: "none",
+      description: "No authentication required",
+      code: `const sdk = new SDK({
+  baseUrl: 'http://localhost:3000'
+});`
+    });
+  }
+  if (auth?.strategy === "api-key") {
+    examples.push({
+      strategy: "apiKey",
+      description: "API Key authentication",
+      code: `const sdk = new SDK({
+  baseUrl: 'https://api.example.com',
+  auth: {
+    apiKey: 'your-api-key',
+    apiKeyHeader: 'x-api-key' // optional, defaults to 'x-api-key'
+  }
+});`
+    });
+  }
+  if (auth?.strategy === "jwt-hs256") {
+    examples.push({
+      strategy: "jwt",
+      description: "JWT Bearer token authentication",
+      code: `const sdk = new SDK({
+  baseUrl: 'https://api.example.com',
+  auth: {
+    jwt: 'your-jwt-token' // or async: () => getToken()
+  }
+});`
+    });
+    examples.push({
+      strategy: "jwt-async",
+      description: "JWT with async token provider",
+      code: `const sdk = new SDK({
+  baseUrl: 'https://api.example.com',
+  auth: {
+    jwt: async () => {
+      const token = await refreshToken();
+      return token;
+    }
+  }
+});`
+    });
+  }
+  examples.push({
+    strategy: "custom",
+    description: "Custom headers provider",
+    code: `const sdk = new SDK({
+  baseUrl: 'https://api.example.com',
+  auth: async () => ({
+    'Authorization': 'Bearer ' + await getToken(),
+    'X-Request-ID': generateRequestId()
+  })
+});`
+  });
+  return examples;
+}
+function generateResourceWithSDK(table, model) {
+  const Type = pascal(table.name);
+  const tableName = table.name;
+  const basePath = `/v1/${tableName}`;
+  const hasSinglePK = table.pk.length === 1;
+  const pkField = hasSinglePK ? table.pk[0] : "id";
+  const sdkMethods = [];
+  const endpoints = [];
+  sdkMethods.push({
+    name: "list",
+    signature: `list(params?: ListParams): Promise<${Type}[]>`,
+    description: `List ${tableName} with filtering, sorting, and pagination`,
+    example: `// Get all ${tableName}
+const items = await sdk.${tableName}.list();
+
+// With filters and pagination
+const filtered = await sdk.${tableName}.list({
+  limit: 20,
+  offset: 0,
+  ${table.columns[0]?.name || "field"}_like: 'search',
+  order_by: '${table.columns[0]?.name || "created_at"}',
+  order_dir: 'desc'
+});
+
+// With related data
+const withRelations = await sdk.${tableName}.list({
+  include: '${table.fks[0]?.toTable || "related_table"}'
+});`,
+    correspondsTo: `GET ${basePath}`
+  });
+  endpoints.push({
+    method: "GET",
+    path: basePath,
+    description: `List all ${tableName} records`,
+    queryParameters: generateQueryParams(table),
+    responseBody: `${Type}[]`
+  });
+  if (hasSinglePK) {
+    sdkMethods.push({
+      name: "getByPk",
+      signature: `getByPk(${pkField}: string, params?: GetParams): Promise<${Type} | null>`,
+      description: `Get a single ${tableName} by primary key`,
+      example: `// Get by ID
+const item = await sdk.${tableName}.getByPk('123e4567-e89b-12d3-a456-426614174000');
+
+// With related data
+const withRelations = await sdk.${tableName}.getByPk('123', {
+  include: '${table.fks[0]?.toTable || "related_table"}'
+});
+
+// Check if exists
+if (item === null) {
+  console.log('Not found');
+}`,
+      correspondsTo: `GET ${basePath}/:${pkField}`
+    });
+    endpoints.push({
+      method: "GET",
+      path: `${basePath}/:${pkField}`,
+      description: `Get ${tableName} by ID`,
+      queryParameters: {
+        include: "string - Comma-separated list of related resources"
+      },
+      responseBody: `${Type}`
+    });
+  }
+  sdkMethods.push({
+    name: "create",
+    signature: `create(data: Insert${Type}): Promise<${Type}>`,
+    description: `Create a new ${tableName}`,
+    example: `import type { Insert${Type} } from './client/types/${tableName}';
+
+const newItem: Insert${Type} = {
+  ${generateExampleFields(table, "create")}
+};
+
+const created = await sdk.${tableName}.create(newItem);
+console.log('Created:', created.${pkField});`,
+    correspondsTo: `POST ${basePath}`
+  });
+  endpoints.push({
+    method: "POST",
+    path: basePath,
+    description: `Create new ${tableName}`,
+    requestBody: `Insert${Type}`,
+    responseBody: `${Type}`
+  });
+  if (hasSinglePK) {
+    sdkMethods.push({
+      name: "update",
+      signature: `update(${pkField}: string, data: Update${Type}): Promise<${Type}>`,
+      description: `Update an existing ${tableName}`,
+      example: `import type { Update${Type} } from './client/types/${tableName}';
+
+const updates: Update${Type} = {
+  ${generateExampleFields(table, "update")}
+};
+
+const updated = await sdk.${tableName}.update('123', updates);`,
+      correspondsTo: `PATCH ${basePath}/:${pkField}`
+    });
+    endpoints.push({
+      method: "PATCH",
+      path: `${basePath}/:${pkField}`,
+      description: `Update ${tableName}`,
+      requestBody: `Update${Type}`,
+      responseBody: `${Type}`
+    });
+  }
+  if (hasSinglePK) {
+    sdkMethods.push({
+      name: "delete",
+      signature: `delete(${pkField}: string): Promise<${Type}>`,
+      description: `Delete a ${tableName}`,
+      example: `const deleted = await sdk.${tableName}.delete('123');
+console.log('Deleted:', deleted);`,
+      correspondsTo: `DELETE ${basePath}/:${pkField}`
+    });
+    endpoints.push({
+      method: "DELETE",
+      path: `${basePath}/:${pkField}`,
+      description: `Delete ${tableName}`,
+      responseBody: `${Type}`
+    });
+  }
+  const fields = table.columns.map((col) => generateFieldContract2(col, table));
+  return {
+    name: Type,
+    tableName,
+    description: `Resource for ${tableName} operations`,
+    sdk: {
+      client: `sdk.${tableName}`,
+      methods: sdkMethods
+    },
+    api: {
+      endpoints
+    },
+    fields
+  };
+}
+function generateFieldContract2(column, table) {
+  const field = {
+    name: column.name,
+    type: postgresTypeToJsonType2(column.pgType),
+    tsType: postgresTypeToTsType(column),
+    required: !column.nullable && !column.hasDefault,
+    description: generateFieldDescription2(column, table)
+  };
+  const fk = table.fks.find((fk2) => fk2.from.length === 1 && fk2.from[0] === column.name);
+  if (fk) {
+    field.foreignKey = {
+      table: fk.toTable,
+      field: fk.to[0] || "id"
+    };
+  }
+  return field;
+}
+function postgresTypeToTsType(column) {
+  const baseType = (() => {
+    switch (column.pgType) {
+      case "int":
+      case "integer":
+      case "smallint":
+      case "bigint":
+      case "decimal":
+      case "numeric":
+      case "real":
+      case "double precision":
+      case "float":
+        return "number";
+      case "boolean":
+      case "bool":
+        return "boolean";
+      case "date":
+      case "timestamp":
+      case "timestamptz":
+        return "string";
+      case "json":
+      case "jsonb":
+        return "Record<string, any>";
+      case "uuid":
+        return "string";
+      case "text[]":
+      case "varchar[]":
+        return "string[]";
+      case "int[]":
+      case "integer[]":
+        return "number[]";
+      default:
+        return "string";
+    }
+  })();
+  if (column.nullable) {
+    return `${baseType} | null`;
+  }
+  return baseType;
+}
+function generateExampleFields(table, operation) {
+  const fields = [];
+  let count = 0;
+  for (const col of table.columns) {
+    if (col.hasDefault && ["id", "created_at", "updated_at"].includes(col.name)) {
+      continue;
+    }
+    if (operation === "update" && count >= 2) {
+      break;
+    }
+    if (operation === "create" && col.nullable && count >= 3) {
+      continue;
+    }
+    const value = generateExampleValue(col);
+    fields.push(`  ${col.name}: ${value}`);
+    count++;
+  }
+  return fields.join(`,
+`);
+}
+function generateExampleValue(column) {
+  const name = column.name.toLowerCase();
+  if (name.includes("email"))
+    return `'user@example.com'`;
+  if (name.includes("name"))
+    return `'John Doe'`;
+  if (name.includes("title"))
+    return `'Example Title'`;
+  if (name.includes("description"))
+    return `'Example description'`;
+  if (name.includes("phone"))
+    return `'+1234567890'`;
+  if (name.includes("url"))
+    return `'https://example.com'`;
+  if (name.includes("price") || name.includes("amount"))
+    return `99.99`;
+  if (name.includes("quantity") || name.includes("count"))
+    return `10`;
+  if (name.includes("status"))
+    return `'active'`;
+  if (name.includes("_id"))
+    return `'related-id-123'`;
+  switch (column.pgType) {
+    case "boolean":
+    case "bool":
+      return "true";
+    case "int":
+    case "integer":
+    case "smallint":
+    case "bigint":
+      return "42";
+    case "decimal":
+    case "numeric":
+    case "real":
+    case "double precision":
+    case "float":
+      return "123.45";
+    case "date":
+      return `'2024-01-01'`;
+    case "timestamp":
+    case "timestamptz":
+      return `'2024-01-01T00:00:00Z'`;
+    case "json":
+    case "jsonb":
+      return `{ key: 'value' }`;
+    case "uuid":
+      return `'123e4567-e89b-12d3-a456-426614174000'`;
+    default:
+      return `'example value'`;
+  }
+}
+function generateQueryParams(table) {
+  const params = {
+    limit: "number - Max records to return (default: 50)",
+    offset: "number - Records to skip",
+    order_by: "string - Field to sort by",
+    order_dir: "'asc' | 'desc' - Sort direction",
+    include: "string - Related resources to include"
+  };
+  let filterCount = 0;
+  for (const col of table.columns) {
+    if (filterCount >= 3)
+      break;
+    const type = postgresTypeToJsonType2(col.pgType);
+    params[col.name] = `${type} - Filter by ${col.name}`;
+    if (type === "string") {
+      params[`${col.name}_like`] = `string - Search in ${col.name}`;
+    } else if (type === "number" || type === "date/datetime") {
+      params[`${col.name}_gt`] = `${type} - Greater than`;
+      params[`${col.name}_lt`] = `${type} - Less than`;
+    }
+    filterCount++;
+  }
+  params["..."] = "Additional filters for all fields";
+  return params;
+}
+function postgresTypeToJsonType2(pgType) {
+  switch (pgType) {
+    case "int":
+    case "integer":
+    case "smallint":
+    case "bigint":
+    case "decimal":
+    case "numeric":
+    case "real":
+    case "double precision":
+    case "float":
+      return "number";
+    case "boolean":
+    case "bool":
+      return "boolean";
+    case "date":
+    case "timestamp":
+    case "timestamptz":
+      return "date/datetime";
+    case "json":
+    case "jsonb":
+      return "object";
+    case "uuid":
+      return "uuid";
+    case "text[]":
+    case "varchar[]":
+      return "string[]";
+    case "int[]":
+    case "integer[]":
+      return "number[]";
+    default:
+      return "string";
+  }
+}
+function generateFieldDescription2(column, table) {
+  const descriptions = [];
+  if (column.name === "id") {
+    descriptions.push("Primary key");
+  } else if (column.name === "created_at") {
+    descriptions.push("Creation timestamp");
+  } else if (column.name === "updated_at") {
+    descriptions.push("Last update timestamp");
+  } else if (column.name === "deleted_at") {
+    descriptions.push("Soft delete timestamp");
+  } else if (column.name.endsWith("_id")) {
+    const relatedTable = column.name.slice(0, -3);
+    descriptions.push(`Foreign key to ${relatedTable}`);
+  } else {
+    descriptions.push(column.name.replace(/_/g, " "));
+  }
+  return descriptions.join(", ");
+}
+function generateUnifiedContractMarkdown(contract) {
+  const lines = [];
+  lines.push("# API & SDK Contract");
+  lines.push("");
+  lines.push(contract.description);
+  lines.push("");
+  lines.push(`**Version:** ${contract.version}`);
+  lines.push(`**Generated:** ${new Date(contract.generatedAt).toLocaleString()}`);
+  lines.push("");
+  lines.push("## SDK Setup");
+  lines.push("");
+  lines.push("### Installation");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# The SDK is generated in the client/ directory");
+  lines.push("# Import it directly from your generated code");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Initialization");
+  lines.push("");
+  for (const example of contract.sdk.initialization) {
+    lines.push(`**${example.description}:**`);
+    lines.push("");
+    lines.push("```typescript");
+    lines.push(example.code);
+    lines.push("```");
+    lines.push("");
+  }
+  if (contract.sdk.authentication.length > 0) {
+    lines.push("### Authentication");
+    lines.push("");
+    for (const auth of contract.sdk.authentication) {
+      lines.push(`**${auth.description}:**`);
+      lines.push("");
+      lines.push("```typescript");
+      lines.push(auth.code);
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  lines.push("## Resources");
+  lines.push("");
+  for (const resource of contract.resources) {
+    lines.push(`### ${resource.name}`);
+    lines.push("");
+    lines.push(resource.description);
+    lines.push("");
+    lines.push("#### SDK Methods");
+    lines.push("");
+    lines.push(`Access via: \`${resource.sdk.client}\``);
+    lines.push("");
+    for (const method of resource.sdk.methods) {
+      lines.push(`**${method.name}**`);
+      lines.push(`- Signature: \`${method.signature}\``);
+      lines.push(`- ${method.description}`);
+      if (method.correspondsTo) {
+        lines.push(`- API: \`${method.correspondsTo}\``);
+      }
+      lines.push("");
+      lines.push("```typescript");
+      lines.push(method.example);
+      lines.push("```");
+      lines.push("");
+    }
+    lines.push("#### API Endpoints");
+    lines.push("");
+    for (const endpoint of resource.api.endpoints) {
+      lines.push(`- \`${endpoint.method} ${endpoint.path}\``);
+      lines.push(`  - ${endpoint.description}`);
+      if (endpoint.requestBody) {
+        lines.push(`  - Request: \`${endpoint.requestBody}\``);
+      }
+      if (endpoint.responseBody) {
+        lines.push(`  - Response: \`${endpoint.responseBody}\``);
+      }
+    }
+    lines.push("");
+    lines.push("#### Fields");
+    lines.push("");
+    lines.push("| Field | Type | TypeScript | Required | Description |");
+    lines.push("|-------|------|------------|----------|-------------|");
+    for (const field of resource.fields) {
+      const required = field.required ? "✓" : "";
+      const fk = field.foreignKey ? ` → ${field.foreignKey.table}` : "";
+      lines.push(`| ${field.name} | ${field.type} | \`${field.tsType}\` | ${required} | ${field.description}${fk} |`);
+    }
+    lines.push("");
+  }
+  if (contract.relationships.length > 0) {
+    lines.push("## Relationships");
+    lines.push("");
+    for (const rel of contract.relationships) {
+      lines.push(`- **${rel.from}** → **${rel.to}** (${rel.type}): ${rel.description}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Type Imports");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("// Import SDK and types");
+  lines.push("import { SDK } from './client';");
+  lines.push("");
+  lines.push("// Import types for a specific table");
+  lines.push("import type {");
+  lines.push("  SelectTableName,  // Full record type");
+  lines.push("  InsertTableName,  // Create payload type");
+  lines.push("  UpdateTableName   // Update payload type");
+  lines.push("} from './client/types/table_name';");
+  lines.push("");
+  lines.push("// Import all types");
+  lines.push("import type * as Types from './client/types';");
+  lines.push("```");
+  lines.push("");
+  return lines.join(`
+`);
+}
+function emitUnifiedContract(model, config) {
+  const contract = generateUnifiedContract(model, config);
+  const contractJson = JSON.stringify(contract, null, 2);
+  return `/**
+ * Unified API & SDK Contract
+ * 
+ * This module exports a comprehensive contract that describes both
+ * API endpoints and SDK usage for all resources.
+ * 
+ * Use this as your primary reference for:
+ * - SDK initialization and authentication
+ * - Available methods and their signatures
+ * - API endpoints and parameters
+ * - Type definitions and relationships
+ */
+
+export const contract = ${contractJson};
+
+export const contractMarkdown = \`${generateUnifiedContractMarkdown(contract).replace(/`/g, "\\`")}\`;
+
+/**
+ * Get the contract in different formats
+ */
+export function getContract(format: 'json' | 'markdown' = 'json') {
+  if (format === 'markdown') {
+    return contractMarkdown;
+  }
+  return contract;
+}
+
+/**
+ * Quick reference for all SDK clients
+ */
+export const sdkClients = ${JSON.stringify(contract.resources.map((r) => ({
+    name: r.tableName,
+    client: r.sdk.client,
+    methods: r.sdk.methods.map((m) => m.name)
+  })), null, 2)};
+
+/**
+ * Type export reference
+ */
+export const typeImports = \`
+// Import the SDK
+import { SDK } from './client';
+
+// Import types for a specific resource
+${contract.resources.slice(0, 1).map((r) => `import type { Select${r.name}, Insert${r.name}, Update${r.name} } from './client/types/${r.tableName}';`).join(`
+`)}
+
+// Import all types
+import type * as Types from './client/types';
+\`;
+`;
+}
+var init_emit_sdk_contract = __esm(() => {
+  init_utils();
+});
+
 // src/cli-init.ts
 var exports_cli_init = {};
 __export(exports_cli_init, {
@@ -978,22 +1647,8 @@ export const buildWithFor = (t: TableName) =>
 `;
 }
 
-// src/utils.ts
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
-var pascal = (s) => s.split(/[_\s-]+/).map((w) => w?.[0] ? w[0].toUpperCase() + w.slice(1) : "").join("");
-async function writeFiles(files) {
-  for (const f of files) {
-    await mkdir(dirname(f.path), { recursive: true });
-    await writeFile(f.path, f.content, "utf-8");
-  }
-}
-async function ensureDirs(dirs) {
-  for (const d of dirs)
-    await mkdir(d, { recursive: true });
-}
-
 // src/emit-zod.ts
+init_utils();
 function emitZod(table, opts) {
   const Type = pascal(table.name);
   const zFor = (pg) => {
@@ -1015,10 +1670,11 @@ function emitZod(table, opts) {
   };
   const fields = table.columns.map((c) => {
     let z = zFor(c.pgType);
-    if (c.nullable)
-      z += `.nullable()`;
-    if (c.hasDefault)
+    if (c.nullable) {
+      z += `.nullish()`;
+    } else if (c.hasDefault) {
       z += `.optional()`;
+    }
     return `  ${c.name}: ${z}`;
   }).join(`,
 `);
@@ -1036,6 +1692,7 @@ export type Update${Type} = z.infer<typeof Update${Type}Schema>;
 }
 
 // src/emit-routes-hono.ts
+init_utils();
 function emitHonoRoutes(table, _graph, opts) {
   const fileTableName = table.name;
   const Type = pascal(table.name);
@@ -1196,6 +1853,7 @@ ${hasAuth ? `
 }
 
 // src/emit-client.ts
+init_utils();
 function emitClient(table, useJsExtensions) {
   const Type = pascal(table.name);
   const ext = useJsExtensions ? ".js" : "";
@@ -1978,6 +2636,7 @@ export async function authMiddleware(c: Context, next: Next) {
 }
 
 // src/emit-router-hono.ts
+init_utils();
 function emitHonoRouter(tables, hasAuth, useJsExtensions) {
   const tableNames = tables.map((t) => t.name).sort();
   const ext = useJsExtensions ? ".js" : "";
@@ -2357,6 +3016,7 @@ export async function deleteRecord(
 }
 
 // src/emit-tests.ts
+init_utils();
 function emitTableTest(table, model, clientPath, framework = "vitest") {
   const Type = pascal(table.name);
   const tableName = table.name;
@@ -2618,11 +3278,80 @@ export TEST_API_URL="http://localhost:3000"
 echo "⏳ Waiting for database..."
 sleep 3
 
-# TODO: Run your migrations on the test database
-# Example:
-# echo "\uD83D\uDCCA Running migrations..."
-# npm run migrate -- --database-url="$TEST_DATABASE_URL"
+# REQUIRED: Run migrations on the test database
+echo ""
+echo "\uD83D\uDCCA Database Migration Step"
+echo "========================================="
+echo ""
+echo "⚠️  IMPORTANT: You must run migrations before tests can work!"
+echo ""
+echo "Choose one of the following options:"
+echo ""
+echo "Option 1: Add your migration command (recommended):"
+echo "  Uncomment and modify one of these examples:"
+echo ""
+echo "  # For Prisma:"
+echo "  # npx prisma migrate deploy"
+echo ""
+echo "  # For Drizzle:"
+echo "  # npx drizzle-kit push --config=./drizzle.config.ts"
+echo ""
+echo "  # For node-pg-migrate:"
+echo "  # npm run migrate up"
+echo ""
+echo "  # For Knex:"
+echo "  # npx knex migrate:latest"
+echo ""
+echo "  # For TypeORM:"
+echo "  # npm run typeorm migration:run"
+echo ""
+echo "  # For custom migration scripts:"
+echo "  # node ./scripts/migrate.js"
+echo ""
+echo "Option 2: Skip migrations (only if your database is already set up):"
+echo "  Uncomment the line: # SKIP_MIGRATIONS=true"
+echo ""
+echo "========================================="
+echo ""
+
+# MIGRATION_COMMAND:
+# Add your migration command here. Examples:
+# MIGRATION_COMMAND="npx prisma migrate deploy"
+# MIGRATION_COMMAND="npx drizzle-kit push --config=./drizzle.config.ts"
+# MIGRATION_COMMAND="npm run migrate up"
+
+# Or skip migrations if your database is pre-configured:
+# SKIP_MIGRATIONS=true
 
+if [ -z "\${MIGRATION_COMMAND}" ] && [ -z "\${SKIP_MIGRATIONS}" ]; then
+  echo "❌ ERROR: No migration strategy configured!"
+  echo ""
+  echo "   Please edit this script and either:"
+  echo "   1. Set MIGRATION_COMMAND with your migration command"
+  echo "   2. Set SKIP_MIGRATIONS=true if migrations aren't needed"
+  echo ""
+  echo "   Tests cannot run without a properly migrated database schema."
+  echo ""
+  exit 1
+fi
+
+if [ ! -z "\${MIGRATION_COMMAND}" ]; then
+  echo "\uD83D\uDCCA Running migrations..."
+  echo "   Command: \${MIGRATION_COMMAND}"
+  eval "\${MIGRATION_COMMAND}"
+  if [ $? -ne 0 ]; then
+    echo "❌ Migration failed! Please check your migration command and database connection."
+    exit 1
+  fi
+  echo "✅ Migrations completed successfully"
+elif [ "\${SKIP_MIGRATIONS}" = "true" ]; then
+  echo "⏭️  Skipping migrations (SKIP_MIGRATIONS=true)"
+else
+  echo "❌ Invalid migration configuration"
+  exit 1
+fi
+
+echo ""
 echo "\uD83D\uDE80 Starting API server..."
 echo "⚠️  TODO: Uncomment and customize the API server startup command below:"
 echo ""
@@ -2996,10 +3725,12 @@ function generateTestCases(table, sampleData, updateData, hasForeignKeys = false
 }
 
 // src/emit-api-contract.ts
+init_utils();
 function generateApiContract(model, config) {
   const resources = [];
   const relationships = [];
-  for (const table of Object.values(model.tables)) {
+  const tables = Object.values(model.tables || {});
+  for (const table of tables) {
     resources.push(generateResourceContract(table, model));
     for (const fk of table.fks) {
       relationships.push({
@@ -3269,6 +4000,10 @@ export function getApiContract(format: 'json' | 'markdown' = 'json') {
 `;
 }
 
+// src/index.ts
+init_emit_sdk_contract();
+init_utils();
+
 // src/types.ts
 function normalizeAuthConfig(input) {
   if (!input)
@@ -3366,6 +4101,9 @@ async function generate(configPath) {
     path: join(serverDir, "core", "operations.ts"),
     content: emitCoreOperations()
   });
+  if (process.env.SDK_DEBUG) {
+    console.log(`[Index] About to process ${Object.keys(model.tables || {}).length} tables for generation`);
+  }
   for (const table of Object.values(model.tables)) {
     const typesSrc = emitTypes(table, { numericMode: "string" });
     files.push({ path: join(serverDir, "types", `${table.name}.ts`), content: typesSrc });
@@ -3415,6 +4153,20 @@ async function generate(configPath) {
     path: join(serverDir, "api-contract.ts"),
     content: emitApiContract(model, cfg)
   });
+  const contractCode = emitUnifiedContract(model, cfg);
+  files.push({
+    path: join(serverDir, "contract.ts"),
+    content: contractCode
+  });
+  const { generateUnifiedContract: generateUnifiedContract2, generateUnifiedContractMarkdown: generateUnifiedContractMarkdown2 } = await Promise.resolve().then(() => (init_emit_sdk_contract(), exports_emit_sdk_contract));
+  if (process.env.SDK_DEBUG) {
+    console.log(`[Index] Model has ${Object.keys(model.tables || {}).length} tables before contract generation`);
+  }
+  const contract = generateUnifiedContract2(model, cfg);
+  files.push({
+    path: join(serverDir, "CONTRACT.md"),
+    content: generateUnifiedContractMarkdown2(contract)
+  });
   if (generateTests) {
     console.log("\uD83E\uDDEA Generating tests...");
     const relativeClientPath = relative(testDir, clientDir);