postgresdk 0.9.2 → 0.9.5

package/dist/cli-config-utils.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from "./types";
+export interface ConfigField {
+    key: string;
+    value: any;
+    description: string;
+    isRequired?: boolean;
+    isCommented?: boolean;
+}
+export declare function parseExistingConfig(configPath: string): {
+    config: Config | null;
+    raw: string;
+};
+export declare function extractConfigFields(configContent: string): ConfigField[];
+export declare function generateMergedConfig(existingFields: ConfigField[], mergeStrategy: "keep-existing" | "use-defaults" | "interactive", userChoices?: Map<string, any> | undefined): string;

package/dist/cli.js

@@ -602,8 +602,12 @@ function generateIncludeMethods(table, graph, opts, allTables) {
               continue;
             const [key1, edge1] = entry1;
             const [key2, edge2] = entry2;
-            if (opts.skipJunctionTables && (edge1.target.includes("_") || edge2.target.includes("_"))) {
-              continue;
+            if (opts.skipJunctionTables && allTables) {
+              const table1 = allTables.find((t) => t.name === edge1.target);
+              const table2 = allTables.find((t) => t.name === edge2.target);
+              if (table1 && isJunctionTable(table1) || table2 && isJunctionTable(table2)) {
+                continue;
+              }
             }
             const combinedPath = [key1, key2];
             const combinedSuffix = `With${pascal(key1)}And${pascal(key2)}`;
@@ -1302,21 +1306,411 @@ var init_emit_sdk_contract = __esm(() => {
   init_emit_include_methods();
 });
 
+// src/cli-config-utils.ts
+function extractConfigFields(configContent) {
+  const fields = [];
+  const connectionMatch = configContent.match(/connectionString:\s*(.+),?$/m);
+  if (connectionMatch) {
+    fields.push({
+      key: "connectionString",
+      value: connectionMatch[1]?.trim(),
+      description: "PostgreSQL connection string",
+      isRequired: true,
+      isCommented: false
+    });
+  }
+  const schemaMatch = configContent.match(/^\s*(\/\/)?\s*schema:\s*"(.+)"/m);
+  if (schemaMatch) {
+    fields.push({
+      key: "schema",
+      value: schemaMatch[2],
+      description: "Database schema to introspect",
+      isCommented: !!schemaMatch[1]
+    });
+  }
+  const outServerMatch = configContent.match(/^\s*(\/\/)?\s*outServer:\s*"(.+)"/m);
+  if (outServerMatch) {
+    fields.push({
+      key: "outServer",
+      value: outServerMatch[2],
+      description: "Output directory for server-side code",
+      isCommented: !!outServerMatch[1]
+    });
+  }
+  const outClientMatch = configContent.match(/^\s*(\/\/)?\s*outClient:\s*"(.+)"/m);
+  if (outClientMatch) {
+    fields.push({
+      key: "outClient",
+      value: outClientMatch[2],
+      description: "Output directory for client SDK",
+      isCommented: !!outClientMatch[1]
+    });
+  }
+  const softDeleteMatch = configContent.match(/^\s*(\/\/)?\s*softDeleteColumn:\s*(.+),?$/m);
+  if (softDeleteMatch) {
+    fields.push({
+      key: "softDeleteColumn",
+      value: softDeleteMatch[2]?.trim().replace(/,$/, "").replace(/["']/g, ""),
+      description: "Column name for soft deletes",
+      isCommented: !!softDeleteMatch[1]
+    });
+  }
+  const depthMatch = configContent.match(/^\s*(\/\/)?\s*includeDepthLimit:\s*(\d+)/m);
+  if (depthMatch) {
+    fields.push({
+      key: "includeDepthLimit",
+      value: parseInt(depthMatch[2]),
+      description: "Maximum depth for nested relationship includes",
+      isCommented: !!depthMatch[1]
+    });
+  }
+  const frameworkMatch = configContent.match(/^\s*(\/\/)?\s*serverFramework:\s*"(.+)"/m);
+  if (frameworkMatch) {
+    fields.push({
+      key: "serverFramework",
+      value: frameworkMatch[2],
+      description: "Server framework for generated API routes",
+      isCommented: !!frameworkMatch[1]
+    });
+  }
+  const jsExtMatch = configContent.match(/^\s*(\/\/)?\s*useJsExtensions:\s*(true|false)/m);
+  if (jsExtMatch) {
+    fields.push({
+      key: "useJsExtensions",
+      value: jsExtMatch[2] === "true",
+      description: "Use .js extensions in server imports",
+      isCommented: !!jsExtMatch[1]
+    });
+  }
+  const jsExtClientMatch = configContent.match(/^\s*(\/\/)?\s*useJsExtensionsClient:\s*(true|false)/m);
+  if (jsExtClientMatch) {
+    fields.push({
+      key: "useJsExtensionsClient",
+      value: jsExtClientMatch[2] === "true",
+      description: "Use .js extensions in client SDK imports",
+      isCommented: !!jsExtClientMatch[1]
+    });
+  }
+  const testsMatch = configContent.match(/^\s*(\/\/)?\s*tests:\s*\{/m);
+  if (testsMatch) {
+    fields.push({
+      key: "tests",
+      value: "configured",
+      description: "Test generation configuration",
+      isCommented: !!testsMatch[1]
+    });
+  }
+  const authMatch = configContent.match(/^\s*(\/\/)?\s*auth:\s*\{/m);
+  if (authMatch) {
+    fields.push({
+      key: "auth",
+      value: "configured",
+      description: "Authentication configuration",
+      isCommented: !!authMatch[1]
+    });
+  }
+  const pullMatch = configContent.match(/^\s*(\/\/)?\s*pull:\s*\{/m);
+  if (pullMatch) {
+    fields.push({
+      key: "pull",
+      value: "configured",
+      description: "SDK distribution configuration",
+      isCommented: !!pullMatch[1]
+    });
+  }
+  return fields;
+}
+function generateMergedConfig(existingFields, mergeStrategy, userChoices = undefined) {
+  const template = `/**
+ * PostgreSDK Configuration
+ * 
+ * This file configures how postgresdk generates your SDK.
+ * Environment variables are automatically loaded from .env files.
+ */
+
+export default {
+  // ========== DATABASE CONNECTION (Required) ==========
+  
+  /**
+   * PostgreSQL connection string
+   * Format: postgres://user:password@host:port/database
+   */
+  connectionString: ${getFieldValue("connectionString", existingFields, mergeStrategy, userChoices)},
+  
+  // ========== BASIC OPTIONS ==========
+  
+  /**
+   * Database schema to introspect
+   * @default "public"
+   */
+  ${getFieldLine("schema", existingFields, mergeStrategy, '"public"', userChoices)}
+  
+  /**
+   * Output directory for server-side code (routes, validators, etc.)
+   * @default "./api/server"
+   */
+  ${getFieldLine("outServer", existingFields, mergeStrategy, '"./api/server"', userChoices)}
+  
+  /**
+   * Output directory for client SDK
+   * @default "./api/client"
+   */
+  ${getFieldLine("outClient", existingFields, mergeStrategy, '"./api/client"', userChoices)}
+  
+  // ========== ADVANCED OPTIONS ==========
+  
+  /**
+   * Column name for soft deletes. When set, DELETE operations will update
+   * this column instead of removing rows.
+   * @default null (hard deletes)
+   * @example "deleted_at"
+   */
+  ${getFieldLine("softDeleteColumn", existingFields, mergeStrategy, "null", userChoices)}
+  
+  /**
+   * Maximum depth for nested relationship includes to prevent infinite loops
+   * @default 3
+   */
+  ${getFieldLine("includeDepthLimit", existingFields, mergeStrategy, "3", userChoices)}
+  
+  
+  /**
+   * Server framework for generated API routes
+   * - "hono": Lightweight, edge-compatible web framework (default)
+   * - "express": Traditional Node.js framework (planned)
+   * - "fastify": High-performance Node.js framework (planned)
+   * @default "hono"
+   */
+  ${getFieldLine("serverFramework", existingFields, mergeStrategy, '"hono"', userChoices)}
+  
+  /**
+   * Use .js extensions in server imports (for Vercel Edge, Deno, etc.)
+   * @default false
+   */
+  ${getFieldLine("useJsExtensions", existingFields, mergeStrategy, "false", userChoices)}
+  
+  /**
+   * Use .js extensions in client SDK imports (rarely needed)
+   * @default false
+   */
+  ${getFieldLine("useJsExtensionsClient", existingFields, mergeStrategy, "false", userChoices)}
+  
+  // ========== TEST GENERATION ==========
+  
+  /**
+   * Generate basic SDK tests
+   * Uncomment to enable test generation with Docker setup
+   */
+  // tests: {
+  //   generate: true,
+  //   output: "./api/tests",
+  //   framework: "vitest"  // or "jest" or "bun"
+  // },
+  
+  // ========== AUTHENTICATION ==========
+  
+  /**
+   * Authentication configuration for your API
+   * 
+   * Simple syntax examples:
+   *   auth: { apiKey: process.env.API_KEY }
+   *   auth: { jwt: process.env.JWT_SECRET }
+   * 
+   * Multiple API keys:
+   *   auth: { apiKeys: [process.env.KEY1, process.env.KEY2] }
+   * 
+   * Full syntax for advanced options:
+   */
+  // auth: {
+  //   // Strategy: "none" | "api-key" | "jwt-hs256"
+  //   strategy: "none",
+  //   
+  //   // For API Key authentication
+  //   apiKeyHeader: "x-api-key",  // Header name for API key
+  //   apiKeys: [                  // List of valid API keys
+  //     process.env.API_KEY_1,
+  //     process.env.API_KEY_2,
+  //   ],
+  //   
+  //   // For JWT (HS256) authentication
+  //   jwt: {
+  //     sharedSecret: process.env.JWT_SECRET,  // Secret for signing/verifying
+  //     issuer: "my-app",                      // Optional: validate 'iss' claim
+  //     audience: "my-users",                  // Optional: validate 'aud' claim
+  //   }
+  // },
+  
+  // ========== SDK DISTRIBUTION (Pull Configuration) ==========
+  
+  /**
+   * Configuration for pulling SDK from a remote API
+   * Used when running 'postgresdk pull' command
+   */
+  // pull: {
+  //   from: "https://api.myapp.com",     // API URL to pull SDK from
+  //   output: "./src/sdk",                // Local directory for pulled SDK
+  //   token: process.env.API_TOKEN,       // Optional authentication token
+  // },
+};
+`;
+  return template;
+}
+function getFieldValue(key, existingFields, mergeStrategy, userChoices) {
+  const existing = existingFields.find((f) => f.key === key);
+  if (mergeStrategy === "keep-existing" && existing && !existing.isCommented) {
+    const value = existing.value.toString().replace(/,\s*$/, "");
+    return value;
+  }
+  if (mergeStrategy === "interactive" && userChoices?.has(key)) {
+    return userChoices.get(key);
+  }
+  return 'process.env.DATABASE_URL || "postgres://user:password@localhost:5432/mydb"';
+}
+function getFieldLine(key, existingFields, mergeStrategy, defaultValue, userChoices) {
+  const existing = existingFields.find((f) => f.key === key);
+  const shouldUseExisting = mergeStrategy === "keep-existing" && existing && !existing.isCommented || mergeStrategy === "interactive" && userChoices?.get(key) === "keep";
+  const shouldUseNew = mergeStrategy === "use-defaults" || mergeStrategy === "interactive" && userChoices?.get(key) === "new";
+  if (shouldUseExisting && existing) {
+    const value = typeof existing.value === "string" && !existing.value.startsWith('"') ? `"${existing.value}"` : existing.value;
+    return `${key}: ${value},`;
+  }
+  if (shouldUseNew) {
+    return `${key}: ${defaultValue},`;
+  }
+  return `// ${key}: ${defaultValue},`;
+}
+var init_cli_config_utils = () => {};
+
 // src/cli-init.ts
 var exports_cli_init = {};
 __export(exports_cli_init, {
   initCommand: () => initCommand
 });
-import { existsSync, writeFileSync } from "fs";
+import { existsSync, writeFileSync, readFileSync, copyFileSync } from "fs";
 import { resolve } from "path";
+import prompts from "prompts";
 async function initCommand(args) {
   console.log(`\uD83D\uDE80 Initializing postgresdk configuration...
 `);
+  const forceError = args.includes("--force-error");
   const configPath = resolve(process.cwd(), "postgresdk.config.ts");
   if (existsSync(configPath)) {
-    console.error("❌ Error: postgresdk.config.ts already exists");
-    console.log("   To reinitialize, please remove or rename the existing file first.");
-    process.exit(1);
+    if (forceError) {
+      console.error("❌ Error: postgresdk.config.ts already exists");
+      console.log("   To reinitialize, please remove or rename the existing file first.");
+      process.exit(1);
+    }
+    console.log(`⚠️  Found existing postgresdk.config.ts
+`);
+    const existingContent = readFileSync(configPath, "utf-8");
+    const existingFields = extractConfigFields(existingContent);
+    console.log("\uD83D\uDCCB Existing configuration detected:");
+    existingFields.forEach((field) => {
+      if (!field.isCommented) {
+        console.log(`   • ${field.description}: ${field.value}`);
+      }
+    });
+    console.log();
+    const { mergeStrategy } = await prompts({
+      type: "select",
+      name: "mergeStrategy",
+      message: "How would you like to proceed?",
+      choices: [
+        {
+          title: "Keep existing values and add new options",
+          value: "keep-existing",
+          description: "Preserves your current settings while adding any new configuration options"
+        },
+        {
+          title: "Interactive merge (recommended)",
+          value: "interactive",
+          description: "Review each setting and choose what to keep"
+        },
+        {
+          title: "Replace with fresh defaults",
+          value: "use-defaults",
+          description: "Creates a new config with default values (backs up existing)"
+        },
+        {
+          title: "Cancel",
+          value: "cancel",
+          description: "Exit without making changes"
+        }
+      ],
+      initial: 1
+    });
+    if (!mergeStrategy || mergeStrategy === "cancel") {
+      console.log(`
+✅ Cancelled. No changes made.`);
+      process.exit(0);
+    }
+    let userChoices;
+    if (mergeStrategy === "interactive") {
+      userChoices = new Map;
+      console.log(`
+\uD83D\uDD04 Let's review your configuration:
+`);
+      for (const field of existingFields.filter((f) => !f.isCommented)) {
+        const { choice } = await prompts({
+          type: "select",
+          name: "choice",
+          message: `${field.description}:
+   Current: ${field.value}
+   Action:`,
+          choices: [
+            { title: "Keep current value", value: "keep" },
+            { title: "Use default value", value: "new" }
+          ],
+          initial: 0
+        });
+        if (!choice) {
+          console.log(`
+✅ Cancelled. No changes made.`);
+          process.exit(0);
+        }
+        userChoices.set(field.key, choice);
+      }
+      const newOptions = [
+        { key: "tests", description: "Enable test generation" },
+        { key: "auth", description: "Add authentication" },
+        { key: "pull", description: "Configure SDK distribution" }
+      ];
+      const existingKeys = new Set(existingFields.map((f) => f.key));
+      const missingOptions = newOptions.filter((opt) => !existingKeys.has(opt.key));
+      if (missingOptions.length > 0) {
+        console.log(`
+\uD83D\uDCE6 New configuration options available:
+`);
+        for (const option of missingOptions) {
+          const { addOption } = await prompts({
+            type: "confirm",
+            name: "addOption",
+            message: `Add ${option.description} configuration? (commented out by default)`,
+            initial: false
+          });
+          if (addOption) {
+            userChoices.set(option.key, "add-commented");
+          }
+        }
+      }
+    }
+    const backupPath = configPath + ".backup." + Date.now();
+    copyFileSync(configPath, backupPath);
+    console.log(`
+\uD83D\uDCBE Backed up existing config to: ${backupPath}`);
+    const mergedConfig = generateMergedConfig(existingFields, mergeStrategy, userChoices);
+    try {
+      writeFileSync(configPath, mergedConfig, "utf-8");
+      console.log("✅ Updated postgresdk.config.ts with merged configuration");
+      console.log(`
+\uD83D\uDCA1 Your previous config has been backed up.`);
+      console.log("   Run 'postgresdk generate' to create your SDK with the new config.");
+    } catch (error) {
+      console.error("❌ Error updating config file:", error);
+      console.log(`   Your backup is available at: ${backupPath}`);
+      process.exit(1);
+    }
+    return;
   }
   const envPath = resolve(process.cwd(), ".env");
   const hasEnv = existsSync(envPath);
@@ -1473,7 +1867,9 @@ export default {
   // },
 };
 `;
-var init_cli_init = () => {};
+var init_cli_init = __esm(() => {
+  init_cli_config_utils();
+});
 
 // src/cli-pull.ts
 var exports_cli_pull = {};
@@ -4234,12 +4630,12 @@ async function generate(configPath) {
 // src/cli.ts
 var import_config2 = __toESM(require_config(), 1);
 import { resolve as resolve3 } from "node:path";
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname as dirname3, join as join3 } from "node:path";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname3(__filename2);
-var packageJson = JSON.parse(readFileSync(join3(__dirname2, "../package.json"), "utf-8"));
+var packageJson = JSON.parse(readFileSync2(join3(__dirname2, "../package.json"), "utf-8"));
 var VERSION = packageJson.version;
 var args = process.argv.slice(2);
 var command = args[0];

package/dist/index.js

@@ -601,8 +601,12 @@ function generateIncludeMethods(table, graph, opts, allTables) {
               continue;
             const [key1, edge1] = entry1;
             const [key2, edge2] = entry2;
-            if (opts.skipJunctionTables && (edge1.target.includes("_") || edge2.target.includes("_"))) {
-              continue;
+            if (opts.skipJunctionTables && allTables) {
+              const table1 = allTables.find((t) => t.name === edge1.target);
+              const table2 = allTables.find((t) => t.name === edge2.target);
+              if (table1 && isJunctionTable(table1) || table2 && isJunctionTable(table2)) {
+                continue;
+              }
             }
             const combinedPath = [key1, key2];
             const combinedSuffix = `With${pascal(key1)}And${pascal(key2)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.9.2",
+  "version": "0.9.5",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "node": ">=18.17"
   },
   "scripts": {
-    "build": "bun build src/cli.ts src/index.ts --outdir dist --target node --format esm --external=pg --external=zod --external=hono --external=node:* && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "build": "bun build src/cli.ts src/index.ts --outdir dist --target node --format esm --external=pg --external=zod --external=hono --external=prompts --external=node:* && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "test": "bun test:init && bun test:gen && bun test:gen-with-tests && bun test:pull && bun test:typecheck && bun test:drizzle-e2e",
     "test:init": "bun test/test-init.ts",
     "test:gen": "bun test/test-gen.ts",
@@ -36,9 +36,11 @@
     "publish:major": "./publish.sh"
   },
   "dependencies": {
+    "@types/prompts": "^2.4.9",
     "dotenv": "^17.2.1",
     "hono": "^4.9.0",
     "pg": "^8.16.3",
+    "prompts": "^2.4.2",
     "zod": "^4.0.15"
   },
   "devDependencies": {