postgresdk 0.6.4 → 0.6.6

package/dist/index.js

@@ -1736,6 +1736,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}";
 ${imports}
 ${hasAuth ? `export { authMiddleware } from "./auth${ext}";` : ""}
 
@@ -1797,6 +1798,29 @@ ${registrations}
     });
   });
   
+  // API Contract endpoints - describes the entire API
+  router.get("/api/contract", (c) => {
+    const format = c.req.query("format") || "json";
+    
+    if (format === "markdown") {
+      return c.text(getApiContract("markdown") as string, 200, {
+        "Content-Type": "text/markdown; charset=utf-8"
+      });
+    }
+    
+    return c.json(getApiContract("json"));
+  });
+  
+  router.get("/api/contract.json", (c) => {
+    return c.json(getApiContract("json"));
+  });
+  
+  router.get("/api/contract.md", (c) => {
+    return c.text(getApiContract("markdown") as string, 200, {
+      "Content-Type": "text/markdown; charset=utf-8"
+    });
+  });
+  
   return router;
 }
 
@@ -2074,30 +2098,44 @@ function emitTableTest(table, clientPath, framework = "vitest") {
   const Type = pascal(table.name);
   const tableName = table.name;
   const imports = getFrameworkImports(framework);
-  const sampleData = generateSampleData(table);
+  const hasForeignKeys = table.fks.length > 0;
+  const foreignKeySetup = hasForeignKeys ? generateForeignKeySetup(table, clientPath) : null;
+  const sampleData = generateSampleData(table, hasForeignKeys);
   const updateData = generateUpdateData(table);
   return `${imports}
 import { SDK } from '${clientPath}';
 import type { Insert${Type}, Update${Type}, Select${Type} } from '${clientPath}/types/${tableName}';
+${foreignKeySetup?.imports || ""}
 
 /**
  * Basic tests for ${tableName} table operations
  * 
  * These tests demonstrate basic CRUD operations.
- * Add your own business logic tests in separate files.
+ * The test data is auto-generated and may need adjustment for your specific schema.
+ * 
+ * If tests fail due to validation errors:
+ * 1. Check which fields are required by your API
+ * 2. Update the test data below to match your schema requirements
+ * 3. Consider adding your own business logic tests in separate files
  */
 describe('${Type} SDK Operations', () => {
   let sdk: SDK;
   let createdId: string;
+  ${foreignKeySetup?.variables || ""}
   
-  beforeAll(() => {
+  beforeAll(async () => {
     sdk = new SDK({ 
       baseUrl: process.env.API_URL || 'http://localhost:3000',
       auth: process.env.API_KEY ? { apiKey: process.env.API_KEY } : undefined
     });
+    ${foreignKeySetup?.setup || ""}
   });
   
-  ${generateTestCases(table, sampleData, updateData)}
+  ${hasForeignKeys && foreignKeySetup?.cleanup ? `afterAll(async () => {
+    ${foreignKeySetup.cleanup}
+  });
+  
+  ` : ""}${generateTestCases(table, sampleData, updateData, hasForeignKeys)}
 });
 `;
 }
@@ -2147,6 +2185,45 @@ export function randomDate(): Date {
 }
 `;
 }
+function emitVitestConfig() {
+  return `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    testTimeout: 30000,
+    hookTimeout: 30000,
+    // The reporters are configured via CLI in the test script
+    // Force color output in terminal
+    pool: 'forks',
+    poolOptions: {
+      forks: {
+        singleFork: true,
+      }
+    }
+  },
+});
+`;
+}
+function emitTestGitignore() {
+  return `# Test results
+test-results/
+*.log
+
+# Node modules (if tests have their own dependencies)
+node_modules/
+
+# Environment files
+.env
+.env.local
+.env.test
+
+# Coverage reports
+coverage/
+*.lcov
+`;
+}
 function emitDockerCompose() {
   return `# Docker Compose for Test Database
 # 
@@ -2205,6 +2282,10 @@ docker-compose up -d --wait
 export TEST_DATABASE_URL="postgres://testuser:testpass@localhost:5432/testdb"
 export TEST_API_URL="http://localhost:3000"
 
+# Force color output for better terminal experience
+export FORCE_COLOR=1
+export CI=""
+
 # Wait for database to be ready
 echo "⏳ Waiting for database..."
 sleep 3
@@ -2232,7 +2313,14 @@ echo ""
 # sleep 3
 
 echo "\uD83E\uDDEA Running tests..."
-${runCommand} "$@"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+TEST_RESULTS_DIR="$SCRIPT_DIR/test-results"
+mkdir -p "$TEST_RESULTS_DIR"
+
+# Run tests with appropriate reporter based on framework
+${getTestCommand(framework, runCommand)}
+
+TEST_EXIT_CODE=$?
 
 # Cleanup
 # if [ ! -z "\${SERVER_PID}" ]; then
@@ -2240,12 +2328,85 @@ ${runCommand} "$@"
 #   kill $SERVER_PID 2>/dev/null || true
 # fi
 
-echo "✅ Tests completed!"
+if [ $TEST_EXIT_CODE -eq 0 ]; then
+  echo "✅ Tests completed successfully!"
+else
+  echo "❌ Tests failed with exit code $TEST_EXIT_CODE"
+fi
+
+echo ""
+echo "\uD83D\uDCCA Test results saved to:"
+echo "  $TEST_RESULTS_DIR/"
 echo ""
 echo "To stop the test database, run:"
 echo "  cd $SCRIPT_DIR && docker-compose down"
+
+exit $TEST_EXIT_CODE
 `;
 }
+function generateForeignKeySetup(table, clientPath) {
+  const imports = [];
+  const variables = [];
+  const setupStatements = [];
+  const cleanupStatements = [];
+  const foreignTables = new Set;
+  for (const fk of table.fks) {
+    const foreignTable = fk.toTable;
+    if (!foreignTables.has(foreignTable)) {
+      foreignTables.add(foreignTable);
+      const ForeignType = pascal(foreignTable);
+      imports.push(`import type { Insert${ForeignType} } from '${clientPath}/types/${foreignTable}';`);
+      variables.push(`let ${foreignTable}Id: string;`);
+      setupStatements.push(`
+    // Create parent ${foreignTable} record for foreign key reference
+    const ${foreignTable}Data = ${generateMinimalSampleData(foreignTable)};
+    const created${ForeignType} = await sdk.${foreignTable}.create(${foreignTable}Data);
+    ${foreignTable}Id = created${ForeignType}.id;`);
+      cleanupStatements.push(`
+    // Clean up parent ${foreignTable} record
+    if (${foreignTable}Id) {
+      try {
+        await sdk.${foreignTable}.delete(${foreignTable}Id);
+      } catch (e) {
+        // Parent might already be deleted due to cascading
+      }
+    }`);
+    }
+  }
+  return {
+    imports: imports.join(`
+`),
+    variables: variables.join(`
+  `),
+    setup: setupStatements.join(""),
+    cleanup: cleanupStatements.join("")
+  };
+}
+function generateMinimalSampleData(tableName) {
+  const commonPatterns = {
+    contacts: `{ name: 'Test Contact', email: 'test@example.com', gender: 'M', date_of_birth: new Date('1990-01-01'), emergency_contact: 'Emergency Contact', clinic_location: 'Main Clinic', specialty: 'General', fmv_tiering: 'Standard', flight_preferences: 'Economy', dietary_restrictions: [], special_accommodations: 'None' }`,
+    tags: `{ name: 'Test Tag' }`,
+    authors: `{ name: 'Test Author' }`,
+    books: `{ title: 'Test Book' }`,
+    users: `{ name: 'Test User', email: 'test@example.com' }`,
+    categories: `{ name: 'Test Category' }`,
+    products: `{ name: 'Test Product', price: 10.99 }`,
+    orders: `{ total: 100.00 }`
+  };
+  return commonPatterns[tableName] || `{ name: 'Test ${pascal(tableName)}' }`;
+}
+function getTestCommand(framework, baseCommand) {
+  switch (framework) {
+    case "vitest":
+      return `FORCE_COLOR=1 ${baseCommand} --reporter=default --reporter=json --outputFile="$TEST_RESULTS_DIR/results-\${TIMESTAMP}.json" "$@"`;
+    case "jest":
+      return `FORCE_COLOR=1 ${baseCommand} --colors --json --outputFile="$TEST_RESULTS_DIR/results-\${TIMESTAMP}.json" "$@"`;
+    case "bun":
+      return `FORCE_COLOR=1 ${baseCommand} "$@" 2>&1 | tee "$TEST_RESULTS_DIR/results-\${TIMESTAMP}.txt"`;
+    default:
+      return `FORCE_COLOR=1 ${baseCommand} "$@"`;
+  }
+}
 function getFrameworkImports(framework) {
   switch (framework) {
     case "vitest":
@@ -2258,17 +2419,38 @@ function getFrameworkImports(framework) {
       return "import { describe, it, expect, beforeAll, afterAll } from 'vitest';";
   }
 }
-function generateSampleData(table) {
+function generateSampleData(table, hasForeignKeys = false) {
   const fields = [];
+  const foreignKeyColumns = new Map;
+  if (hasForeignKeys) {
+    for (const fk of table.fks) {
+      if (fk.from.length === 1 && fk.from[0]) {
+        foreignKeyColumns.set(fk.from[0], fk.toTable);
+      }
+    }
+  }
   for (const col of table.columns) {
-    if (col.hasDefault || col.name === "id" || col.name === "created_at" || col.name === "updated_at") {
+    if (col.name === "id" && col.hasDefault) {
+      continue;
+    }
+    if ((col.name === "created_at" || col.name === "updated_at") && col.hasDefault) {
       continue;
     }
-    if (col.nullable) {
+    if (col.name === "deleted_at") {
       continue;
     }
-    const value = getSampleValue(col.pgType, col.name);
-    fields.push(`    ${col.name}: ${value}`);
+    if (!col.nullable) {
+      const foreignTable = foreignKeyColumns.get(col.name);
+      const value = foreignTable ? `${foreignTable}Id` : getSampleValue(col.pgType, col.name);
+      fields.push(`    ${col.name}: ${value}`);
+    } else {
+      const isImportant = col.name.endsWith("_id") || col.name.endsWith("_by") || col.name.includes("email") || col.name.includes("name") || col.name.includes("phone") || col.name.includes("address") || col.name.includes("description") || col.name.includes("color") || col.name.includes("type") || col.name.includes("status") || col.name.includes("subject");
+      if (isImportant) {
+        const foreignTable = foreignKeyColumns.get(col.name);
+        const value = foreignTable ? `${foreignTable}Id` : getSampleValue(col.pgType, col.name);
+        fields.push(`    ${col.name}: ${value}`);
+      }
+    }
   }
   return fields.length > 0 ? `{
 ${fields.join(`,
@@ -2294,15 +2476,63 @@ ${fields.join(`,
 }
 function getSampleValue(type, name, isUpdate = false) {
   const suffix = isUpdate ? ' + " (updated)"' : "";
+  if (name.endsWith("_id") || name.endsWith("_by")) {
+    return `'550e8400-e29b-41d4-a716-446655440000'`;
+  }
   if (name.includes("email")) {
     return `'test${isUpdate ? ".updated" : ""}@example.com'`;
   }
+  if (name === "color") {
+    return `'#${isUpdate ? "FF0000" : "0000FF"}'`;
+  }
+  if (name === "gender") {
+    return `'${isUpdate ? "F" : "M"}'`;
+  }
+  if (name.includes("phone")) {
+    return `'${isUpdate ? "555-0200" : "555-0100"}'`;
+  }
+  if (name.includes("address")) {
+    return `'123 ${isUpdate ? "Updated" : "Test"} Street'`;
+  }
+  if (name === "type" || name === "status") {
+    return `'${isUpdate ? "updated" : "active"}'`;
+  }
+  if (name === "subject") {
+    return `'Test Subject${isUpdate ? " Updated" : ""}'`;
+  }
   if (name.includes("name") || name.includes("title")) {
     return `'Test ${pascal(name)}'${suffix}`;
   }
   if (name.includes("description") || name.includes("bio") || name.includes("content")) {
     return `'Test description'${suffix}`;
   }
+  if (name.includes("preferences") || name.includes("settings")) {
+    return `'Test preferences'${suffix}`;
+  }
+  if (name.includes("restrictions") || name.includes("dietary")) {
+    return `['vegetarian']`;
+  }
+  if (name.includes("location") || name.includes("clinic")) {
+    return `'Test Location'${suffix}`;
+  }
+  if (name.includes("specialty")) {
+    return `'General'`;
+  }
+  if (name.includes("tier")) {
+    return `'Standard'`;
+  }
+  if (name.includes("emergency")) {
+    return `'Emergency Contact ${isUpdate ? "Updated" : "Name"}'`;
+  }
+  if (name === "date_of_birth" || name.includes("birth")) {
+    return `new Date('1990-01-01')`;
+  }
+  if (name.includes("accommodations")) {
+    return `'No special accommodations'`;
+  }
+  if (name.includes("flight")) {
+    return `'Economy'`;
+  }
   switch (type) {
     case "text":
     case "varchar":
@@ -2326,17 +2556,20 @@ function getSampleValue(type, name, isUpdate = false) {
       return `'2024-01-01'`;
     case "timestamp":
     case "timestamptz":
-      return `new Date().toISOString()`;
+      return `new Date()`;
     case "json":
     case "jsonb":
       return `{ key: 'value' }`;
     case "uuid":
-      return `'${isUpdate ? "b" : "a"}0e0e0e0-e0e0-e0e0-e0e0-e0e0e0e0e0e0'`;
+      return `'${isUpdate ? "550e8400-e29b-41d4-a716-446655440001" : "550e8400-e29b-41d4-a716-446655440000"}'`;
+    case "text[]":
+    case "varchar[]":
+      return `['item1', 'item2']`;
     default:
       return `'test'`;
   }
 }
-function generateTestCases(table, sampleData, updateData) {
+function generateTestCases(table, sampleData, updateData, hasForeignKeys = false) {
   const Type = pascal(table.name);
   const hasData = sampleData !== "{}";
   return `it('should create a ${table.name}', async () => {
@@ -2395,6 +2628,280 @@ function generateTestCases(table, sampleData, updateData) {
   });` : ""}`;
 }
 
+// src/emit-api-contract.ts
+function generateApiContract(model, config) {
+  const resources = [];
+  const relationships = [];
+  for (const table of Object.values(model.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/types.ts
 function normalizeAuthConfig(input) {
   if (!input)
@@ -2538,6 +3045,10 @@ 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)
+  });
   if (generateTests) {
     console.log("\uD83E\uDDEA Generating tests...");
     const relativeClientPath = relative(testDir, clientDir);
@@ -2553,6 +3064,16 @@ async function generate(configPath) {
       path: join(testDir, "run-tests.sh"),
       content: emitTestScript(testFramework)
     });
+    files.push({
+      path: join(testDir, ".gitignore"),
+      content: emitTestGitignore()
+    });
+    if (testFramework === "vitest") {
+      files.push({
+        path: join(testDir, "vitest.config.ts"),
+        content: emitVitestConfig()
+      });
+    }
     for (const table of Object.values(model.tables)) {
       files.push({
         path: join(testDir, `${table.name}.test.ts`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {
@@ -28,6 +28,7 @@
     "test:gen-with-tests": "bun src/cli.ts generate -c test/test-with-tests.config.ts",
     "test:pull": "bun test/test-pull.ts",
     "test:typecheck": "bun test/test-typecheck.ts",
+    "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
     "publish:patch": "./publish.sh",
     "publish:minor": "./publish.sh",