postgresdk 0.6.17 → 0.7.1

package/dist/index.js

@@ -743,7 +743,7 @@ console.log('Deleted:', deleted);`,
       responseBody: `${Type}`
     });
   }
-  const fields = table.columns.map((col) => generateFieldContract2(col, table));
+  const fields = table.columns.map((col) => generateFieldContract(col, table));
   return {
     name: Type,
     tableName,
@@ -758,13 +758,13 @@ console.log('Deleted:', deleted);`,
     fields
   };
 }
-function generateFieldContract2(column, table) {
+function generateFieldContract(column, table) {
   const field = {
     name: column.name,
-    type: postgresTypeToJsonType2(column.pgType),
+    type: postgresTypeToJsonType(column.pgType),
     tsType: postgresTypeToTsType(column),
     required: !column.nullable && !column.hasDefault,
-    description: generateFieldDescription2(column, table)
+    description: generateFieldDescription(column, table)
   };
   const fk = table.fks.find((fk2) => fk2.from.length === 1 && fk2.from[0] === column.name);
   if (fk) {
@@ -898,7 +898,7 @@ function generateQueryParams(table) {
   for (const col of table.columns) {
     if (filterCount >= 3)
       break;
-    const type = postgresTypeToJsonType2(col.pgType);
+    const type = postgresTypeToJsonType(col.pgType);
     params[col.name] = `${type} - Filter by ${col.name}`;
     if (type === "string") {
       params[`${col.name}_like`] = `string - Search in ${col.name}`;
@@ -911,7 +911,7 @@ function generateQueryParams(table) {
   params["..."] = "Additional filters for all fields";
   return params;
 }
-function postgresTypeToJsonType2(pgType) {
+function postgresTypeToJsonType(pgType) {
   switch (pgType) {
     case "int":
     case "integer":
@@ -945,7 +945,7 @@ function postgresTypeToJsonType2(pgType) {
       return "string";
   }
 }
-function generateFieldDescription2(column, table) {
+function generateFieldDescription(column, table) {
   const descriptions = [];
   if (column.name === "id") {
     descriptions.push("Primary key");
@@ -1422,9 +1422,6 @@ ${fields}
 });
 
 export const Update${Type}Schema = Insert${Type}Schema.partial();
-
-export type Insert${Type} = z.infer<typeof Insert${Type}Schema>;
-export type Update${Type} = z.infer<typeof Update${Type}Schema>;
 `;
 }
 
@@ -1653,9 +1650,7 @@ function emitClientIndex(tables, useJsExtensions) {
 `;
   }
   out += `
-// Re-export auth types for convenience
-`;
-  out += `export type { AuthConfig as SDKAuth, AuthConfig, HeaderMap, AuthHeadersProvider } from "./base-client${ext}";
+export type { AuthConfig, HeaderMap, AuthHeadersProvider } from "./base-client${ext}";
 
 `;
   out += `/**
@@ -1683,23 +1678,18 @@ function emitClientIndex(tables, useJsExtensions) {
 `;
   out += `}
 
-`;
-  out += `// Export individual table clients
-`;
-  for (const t of tables) {
-    out += `export { ${pascal(t.name)}Client } from "./${t.name}${ext}";
-`;
-  }
-  out += `
-// Export base client for custom extensions
 `;
   out += `export { BaseClient } from "./base-client${ext}";
+`;
+  out += `export * from "./include-spec${ext}";
 `;
   out += `
-// Export include specifications
+// Zod schemas for form validation
 `;
-  out += `export * from "./include-spec${ext}";
+  for (const t of tables) {
+    out += `export { Insert${pascal(t.name)}Schema, Update${pascal(t.name)}Schema } from "./zod/${t.name}${ext}";
 `;
+  }
   return out;
 }
 
@@ -2395,7 +2385,7 @@ function emitHonoRouter(tables, hasAuth, useJsExtensions) {
   return `/* Generated. Do not edit. */
 import { Hono } from "hono";
 import { SDK_MANIFEST } from "./sdk-bundle${ext}";
-import { getApiContract } from "./api-contract${ext}";
+import { getContract } from "./contract${ext}";
 ${imports}
 ${hasAuth ? `export { authMiddleware } from "./auth${ext}";` : ""}
 
@@ -2462,20 +2452,20 @@ ${registrations}
     const format = c.req.query("format") || "json";
     
     if (format === "markdown") {
-      return c.text(getApiContract("markdown") as string, 200, {
+      return c.text(getContract("markdown") as string, 200, {
         "Content-Type": "text/markdown; charset=utf-8"
       });
     }
     
-    return c.json(getApiContract("json"));
+    return c.json(getContract("json"));
   });
   
   router.get("/api/contract.json", (c) => {
-    return c.json(getApiContract("json"));
+    return c.json(getContract("json"));
   });
   
   router.get("/api/contract.md", (c) => {
-    return c.text(getApiContract("markdown") as string, 200, {
+    return c.text(getContract("markdown") as string, 200, {
       "Content-Type": "text/markdown; charset=utf-8"
     });
   });
@@ -3055,6 +3045,8 @@ if [ ! -z "\${MIGRATION_COMMAND}" ]; then
     exit 1
   fi
   echo "✅ Migrations completed successfully"
+  echo "⏳ Waiting for database to settle..."
+  sleep 2
 elif [ "\${SKIP_MIGRATIONS}" = "true" ]; then
   echo "⏭️  Skipping migrations (SKIP_MIGRATIONS=true)"
 else
@@ -3439,282 +3431,6 @@ function generateTestCases(table, sampleData, updateData, hasForeignKeys = false
   });` : ""}`;
 }
 
-// src/emit-api-contract.ts
-init_utils();
-function generateApiContract(model, config) {
-  const resources = [];
-  const relationships = [];
-  const tables = Object.values(model.tables || {});
-  for (const table of tables) {
-    resources.push(generateResourceContract(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: "1.0.0",
-    generatedAt: new Date().toISOString(),
-    description: "Auto-generated API contract describing all available endpoints, resources, and their relationships",
-    resources,
-    relationships
-  };
-  if (config.auth?.strategy && config.auth.strategy !== "none") {
-    contract.authentication = {
-      type: config.auth.strategy,
-      description: getAuthDescription(config.auth.strategy)
-    };
-  }
-  return contract;
-}
-function generateResourceContract(table, model) {
-  const Type = pascal(table.name);
-  const basePath = `/v1/${table.name}`;
-  const endpoints = [
-    {
-      method: "GET",
-      path: basePath,
-      description: `List all ${table.name} records with optional filtering, sorting, and pagination`,
-      queryParameters: {
-        limit: "number - Maximum number of records to return (default: 50)",
-        offset: "number - Number of records to skip for pagination",
-        order_by: "string - Field to sort by",
-        order_dir: "string - Sort direction (asc or desc)",
-        include: "string - Comma-separated list of related resources to include",
-        ...generateFilterParams(table)
-      },
-      responseBody: `Array<${Type}>`
-    },
-    {
-      method: "GET",
-      path: `${basePath}/:id`,
-      description: `Get a single ${table.name} record by ID`,
-      queryParameters: {
-        include: "string - Comma-separated list of related resources to include"
-      },
-      responseBody: `${Type}`
-    },
-    {
-      method: "POST",
-      path: basePath,
-      description: `Create a new ${table.name} record`,
-      requestBody: `Insert${Type}`,
-      responseBody: `${Type}`
-    },
-    {
-      method: "PATCH",
-      path: `${basePath}/:id`,
-      description: `Update an existing ${table.name} record`,
-      requestBody: `Update${Type}`,
-      responseBody: `${Type}`
-    },
-    {
-      method: "DELETE",
-      path: `${basePath}/:id`,
-      description: `Delete a ${table.name} record`,
-      responseBody: `${Type}`
-    }
-  ];
-  const fields = table.columns.map((col) => generateFieldContract(col, table));
-  return {
-    name: Type,
-    tableName: table.name,
-    description: `Resource for managing ${table.name} records`,
-    endpoints,
-    fields
-  };
-}
-function generateFieldContract(column, table) {
-  const field = {
-    name: column.name,
-    type: postgresTypeToJsonType(column.pgType),
-    required: !column.nullable && !column.hasDefault,
-    description: generateFieldDescription(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 generateFieldDescription(column, table) {
-  const descriptions = [];
-  descriptions.push(`${postgresTypeToJsonType(column.pgType)} field`);
-  if (column.name === "id") {
-    descriptions.push("Unique identifier");
-  } else if (column.name === "created_at") {
-    descriptions.push("Timestamp when the record was created");
-  } else if (column.name === "updated_at") {
-    descriptions.push("Timestamp when the record was last updated");
-  } 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(`Reference to ${relatedTable}`);
-  } else if (column.name.includes("email")) {
-    descriptions.push("Email address");
-  } else if (column.name.includes("phone")) {
-    descriptions.push("Phone number");
-  } else if (column.name.includes("name")) {
-    descriptions.push("Name field");
-  } else if (column.name.includes("description")) {
-    descriptions.push("Description text");
-  } else if (column.name.includes("status")) {
-    descriptions.push("Status indicator");
-  } else if (column.name.includes("price") || column.name.includes("amount") || column.name.includes("total")) {
-    descriptions.push("Monetary value");
-  }
-  if (!column.nullable && !column.hasDefault) {
-    descriptions.push("(required)");
-  } else if (column.nullable) {
-    descriptions.push("(optional)");
-  }
-  return descriptions.join(" - ");
-}
-function postgresTypeToJsonType(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 "array<string>";
-    case "int[]":
-    case "integer[]":
-      return "array<number>";
-    default:
-      return "string";
-  }
-}
-function generateFilterParams(table) {
-  const filters = {};
-  for (const col of table.columns) {
-    const type = postgresTypeToJsonType(col.pgType);
-    filters[col.name] = `${type} - Filter by exact ${col.name} value`;
-    if (type === "number" || type === "date/datetime") {
-      filters[`${col.name}_gt`] = `${type} - Filter where ${col.name} is greater than`;
-      filters[`${col.name}_gte`] = `${type} - Filter where ${col.name} is greater than or equal`;
-      filters[`${col.name}_lt`] = `${type} - Filter where ${col.name} is less than`;
-      filters[`${col.name}_lte`] = `${type} - Filter where ${col.name} is less than or equal`;
-    }
-    if (type === "string") {
-      filters[`${col.name}_like`] = `string - Filter where ${col.name} contains text (case-insensitive)`;
-    }
-  }
-  return filters;
-}
-function getAuthDescription(strategy) {
-  switch (strategy) {
-    case "jwt":
-      return "JWT Bearer token authentication. Include token in Authorization header: 'Bearer <token>'";
-    case "apiKey":
-      return "API Key authentication. Include key in the configured header (e.g., 'x-api-key')";
-    default:
-      return "Custom authentication strategy";
-  }
-}
-function generateApiContractMarkdown(contract) {
-  const lines = [];
-  lines.push("# API Contract");
-  lines.push("");
-  lines.push(contract.description);
-  lines.push("");
-  lines.push(`**Version:** ${contract.version}`);
-  lines.push(`**Generated:** ${new Date(contract.generatedAt).toLocaleString()}`);
-  lines.push("");
-  if (contract.authentication) {
-    lines.push("## Authentication");
-    lines.push("");
-    lines.push(`**Type:** ${contract.authentication.type}`);
-    lines.push("");
-    lines.push(contract.authentication.description);
-    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("**Endpoints:**");
-    lines.push("");
-    for (const endpoint of resource.endpoints) {
-      lines.push(`- \`${endpoint.method} ${endpoint.path}\` - ${endpoint.description}`);
-    }
-    lines.push("");
-    lines.push("**Fields:**");
-    lines.push("");
-    for (const field of resource.fields) {
-      const required = field.required ? " *(required)*" : "";
-      const fk = field.foreignKey ? ` → ${field.foreignKey.table}` : "";
-      lines.push(`- \`${field.name}\` (${field.type})${required}${fk} - ${field.description}`);
-    }
-    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("");
-  }
-  return lines.join(`
-`);
-}
-function emitApiContract(model, config) {
-  const contract = generateApiContract(model, config);
-  const contractJson = JSON.stringify(contract, null, 2);
-  return `/**
- * API Contract
- * 
- * This module exports the API contract that describes all available
- * endpoints, resources, and their relationships.
- */
-
-export const apiContract = ${contractJson};
-
-export const apiContractMarkdown = \`${generateApiContractMarkdown(contract).replace(/`/g, "\\`")}\`;
-
-/**
- * Helper to get the contract in different formats
- */
-export function getApiContract(format: 'json' | 'markdown' = 'json') {
-  if (format === 'markdown') {
-    return apiContractMarkdown;
-  }
-  return apiContract;
-}
-`;
-}
-
 // src/index.ts
 init_emit_sdk_contract();
 init_utils();
@@ -3789,7 +3505,8 @@ async function generate(configPath) {
     join(serverDir, "zod"),
     join(serverDir, "routes"),
     clientDir,
-    join(clientDir, "types")
+    join(clientDir, "types"),
+    join(clientDir, "zod")
   ];
   if (generateTests) {
     dirs.push(testDir);
@@ -3823,10 +3540,9 @@ async function generate(configPath) {
     const typesSrc = emitTypes(table, { numericMode: "string" });
     files.push({ path: join(serverDir, "types", `${table.name}.ts`), content: typesSrc });
     files.push({ path: join(clientDir, "types", `${table.name}.ts`), content: typesSrc });
-    files.push({
-      path: join(serverDir, "zod", `${table.name}.ts`),
-      content: emitZod(table, { numericMode: "string" })
-    });
+    const zodSrc = emitZod(table, { numericMode: "string" });
+    files.push({ path: join(serverDir, "zod", `${table.name}.ts`), content: zodSrc });
+    files.push({ path: join(clientDir, "zod", `${table.name}.ts`), content: zodSrc });
     let routeContent;
     if (serverFramework === "hono") {
       routeContent = emitHonoRoutes(table, graph, {
@@ -3864,10 +3580,6 @@ async function generate(configPath) {
     path: join(serverDir, "sdk-bundle.ts"),
     content: emitSdkBundle(clientFiles, clientDir)
   });
-  files.push({
-    path: join(serverDir, "api-contract.ts"),
-    content: emitApiContract(model, cfg)
-  });
   const contractCode = emitUnifiedContract(model, cfg);
   files.push({
     path: join(serverDir, "contract.ts"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.6.17",
+  "version": "0.7.1",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {
@@ -42,6 +42,7 @@
     "zod": "^4.0.15"
   },
   "devDependencies": {
+    "@types/bun": "^1.2.20",
     "@types/node": "^20.0.0",
     "@types/pg": "^8.15.5",
     "drizzle-kit": "^0.31.4",