postgresdk 0.1.2-alpha.4 → 0.2.0

package/README.md

@@ -35,7 +35,7 @@ CREATE TABLE book_tags (
 Run one command:
 
 ```bash
-npx postgresdk
+npx postgresdk generate
 ```
 
 Get a complete, type-safe SDK with:
@@ -140,36 +140,43 @@ All from your existing database schema. No manual coding required.
 - 🔐 **Built-in Auth** - API key and JWT authentication with zero configuration
 - 🎯 **Zero Config** - Works out of the box with sensible defaults
 - 🏗️ **Framework Ready** - Server routes built for Hono, client SDK works anywhere
-- 📦 **Lightweight** - Minimal dependencies, optimized for production
+- 📦 **Lightweight** - Minimal dependencies, optimized bundle size with shared BaseClient
+- 🔄 **SDK Distribution** - Built-in SDK bundling and pull mechanism for easy client distribution
 
 ## Installation
 
 ```bash
 npm install -g postgresdk
 # or
-npx postgresdk
+npx postgresdk generate
 ```
 
 ## Quick Start
 
-1. Create a configuration file `postgresdk.config.ts`:
+1. Initialize your project:
+
+```bash
+npx postgresdk init
+```
+
+This creates a `postgresdk.config.ts` file with all available options documented.
+
+2. Edit the configuration file with your database connection:
 
 ```typescript
 export default {
-  connectionString: "postgres://user:pass@localhost:5432/mydb",
-  schema: "public",
-  outServer: "./generated/server",
-  outClient: "./generated/client",
+  connectionString: process.env.DATABASE_URL || "postgres://user:pass@localhost:5432/mydb",
+  // Uncomment and customize other options as needed
 };
 ```
 
-2. Run the generator:
+3. Run the generator:
 
 ```bash
-postgresdk
+postgresdk generate
 ```
 
-3. Use the generated SDK:
+4. Use the generated SDK:
 
 ```typescript
 // Server (Hono)
@@ -212,19 +219,19 @@ export default {
   includeDepthLimit: 3,                 // Max depth for nested includes
   dateType: "date",                    // "date" | "string" - How to handle timestamps
   
-  // Authentication (optional)
+  // Authentication (optional) - simplified syntax
   auth: {
+    apiKey: process.env.API_KEY,        // Simple API key auth
+    // OR
+    jwt: process.env.JWT_SECRET,        // Simple JWT auth
+    // OR full syntax for advanced options:
     strategy: "none" | "api-key" | "jwt-hs256",  // Default: "none"
-    
-    // For API key auth
-    apiKeyHeader: "x-api-key",         // Header name for API key
-    apiKeys: ["key1", "key2"],         // Array of valid keys
-    
-    // For JWT auth (HS256)
+    apiKeyHeader: "x-api-key",          // Custom header name
+    apiKeys: ["key1", "key2"],          // Multiple valid keys
     jwt: {
-      sharedSecret: "your-secret",     // Shared secret for HS256
-      issuer: "your-app",               // Optional: validate issuer claim
-      audience: "your-audience"        // Optional: validate audience claim
+      sharedSecret: "your-secret",      // Shared secret for HS256
+      issuer: "your-app",                // Optional: validate issuer claim
+      audience: "your-audience"         // Optional: validate audience claim
     }
   }
 };
@@ -348,11 +355,11 @@ export default {
 ### API Key Authentication
 
 ```typescript
-// postgresdk.config.ts - Simplified syntax
+// postgresdk.config.ts - Simple syntax (recommended)
 export default {
   connectionString: "...",
   auth: {
-    apiKey: "your-api-key"  // Single key shorthand
+    apiKey: process.env.API_KEY  // Single key shorthand
   }
 };
 
@@ -360,50 +367,45 @@ export default {
 export default {
   connectionString: "...",
   auth: {
-    apiKeys: ["key1", "key2", "key3"]
+    apiKeys: [process.env.API_KEY_1, process.env.API_KEY_2]
   }
 };
 
-// Or full syntax with custom header
+// Full syntax with custom header (optional)
 export default {
   connectionString: "...",
   auth: {
     strategy: "api-key",
-    apiKeyHeader: "x-api-key",  // Optional, defaults to "x-api-key"
-    apiKeys: [
-      "your-api-key-1",
-      "your-api-key-2",
-      // Can also use environment variables
-      "env:API_KEYS"  // Reads comma-separated keys from process.env.API_KEYS
-    ]
+    apiKeyHeader: "x-custom-key",  // Default: "x-api-key"
+    apiKeys: ["key1", "key2"]
   }
 };
 
 // Client SDK usage
 const sdk = new SDK({
   baseUrl: "http://localhost:3000",
-  auth: { apiKey: "your-api-key-1" }
+  auth: { apiKey: process.env.API_KEY }
 });
 ```
 
 ### JWT Authentication (HS256)
 
 ```typescript
-// postgresdk.config.ts - Simplified syntax
+// postgresdk.config.ts - Simple syntax (recommended)
 export default {
   connectionString: "...",
   auth: {
-    jwt: "your-secret-key"  // Shared secret shorthand
+    jwt: process.env.JWT_SECRET  // Shared secret shorthand
   }
 };
 
-// Or full syntax with issuer/audience validation
+// Full syntax with issuer/audience validation (optional)
 export default {
   connectionString: "...",
   auth: {
     strategy: "jwt-hs256",
     jwt: {
-      sharedSecret: process.env.JWT_SECRET || "your-secret-key",
+      sharedSecret: process.env.JWT_SECRET,
       issuer: "my-app",        // Optional: validates 'iss' claim
       audience: "my-users"     // Optional: validates 'aud' claim
     }
@@ -772,15 +774,114 @@ process.on("SIGTERM", async () => {
 });
 ```
 
-## CLI Options
+## SDK Distribution
+
+postgresdk makes it easy to distribute your generated SDK to client applications. When you generate your SDK, it's automatically bundled and served through your API, allowing client apps to pull the latest SDK directly.
+
+### Publishing Your SDK
+
+When you run `postgresdk generate`, the SDK is automatically:
+1. Generated as TypeScript files for both server and client
+2. Bundled and made available through API endpoints
+3. Ready to be pulled by client applications
+
+Your API automatically serves the SDK at these endpoints:
+- `GET /sdk/manifest` - SDK metadata and file list
+- `GET /sdk/download` - Download all SDK files as JSON
+- `GET /sdk/files/:path` - Download individual SDK files
+
+### Pulling the SDK in Client Apps
+
+Client applications can pull your SDK using the `postgresdk pull` command:
+
+```bash
+# Install postgresdk in your client app
+npm install -D postgresdk
+
+# Pull the SDK from your API
+postgresdk pull --from=https://api.myapp.com --output=./src/sdk
+
+# Or with authentication
+postgresdk pull --from=https://api.myapp.com --output=./src/sdk --token=your-token
+```
+
+### Configuration-based Pull
+
+Create a `postgresdk.config.ts` in your client app:
+
+```typescript
+export default {
+  pull: {
+    from: "https://api.myapp.com",
+    output: "./src/sdk",
+    token: process.env.API_TOKEN  // Optional auth
+  }
+};
+```
+
+Then simply run:
+```bash
+postgresdk pull
+```
+
+### Automated SDK Updates
+
+You can automate SDK updates in your client app's build process:
+
+```json
+// package.json
+{
+  "scripts": {
+    "prebuild": "postgresdk pull",
+    "build": "tsc"
+  }
+}
+```
+
+### SDK Versioning
+
+The pulled SDK includes metadata about when it was generated and from where:
+
+```typescript
+// .postgresdk.json (auto-generated)
+{
+  "version": "1.0.0",
+  "generated": "2024-01-15T10:30:00Z",
+  "pulledFrom": "https://api.myapp.com",
+  "pulledAt": "2024-01-15T11:00:00Z"
+}
+```
+
+## CLI Commands
 
 ```bash
-postgresdk [options]
+postgresdk <command> [options]
+
+Commands:
+  init                 Create a postgresdk.config.ts file with all options
+  generate             Generate SDK from database
+  pull                 Pull SDK from API endpoint
+  version              Show version
+  help                 Show help
 
-Options:
+Init Options:
+  (no options)         Creates postgresdk.config.ts in current directory
+
+Generate Options:
   -c, --config <path>  Path to config file (default: postgresdk.config.ts)
-  -v, --version        Show version
-  -h, --help           Show help
+
+Pull Options:
+  --from <url>         API URL to pull SDK from
+  --output <path>      Output directory (default: ./src/sdk)
+  --token <token>      Authentication token
+  -c, --config <path>  Path to config file with pull settings
+
+Examples:
+  postgresdk init                        # Create config file
+  postgresdk generate                    # Generate using default config
+  postgresdk generate -c custom.config.ts
+  postgresdk pull --from=https://api.com --output=./src/sdk
+  postgresdk pull -c client.config.ts    # Pull using config file
 ```
 
 ## How It Works

package/dist/cli-init.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function initCommand(args: string[]): Promise<void>;

package/dist/cli-pull.d.ts

@@ -0,0 +1 @@
+export declare function pullCommand(args: string[]): Promise<void>;

package/dist/cli.js

@@ -17,6 +17,16 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/dotenv/package.json
@@ -460,6 +470,242 @@ var require_config = __commonJS(() => {
   })();
 });
 
+// src/cli-init.ts
+var exports_cli_init = {};
+__export(exports_cli_init, {
+  initCommand: () => initCommand
+});
+import { existsSync, writeFileSync } from "fs";
+import { resolve } from "path";
+async function initCommand(args) {
+  console.log(`\uD83D\uDE80 Initializing postgresdk configuration...
+`);
+  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);
+  }
+  const envPath = resolve(process.cwd(), ".env");
+  const hasEnv = existsSync(envPath);
+  try {
+    writeFileSync(configPath, CONFIG_TEMPLATE, "utf-8");
+    console.log("✅ Created postgresdk.config.ts");
+    console.log(`
+\uD83D\uDCDD Next steps:`);
+    console.log("   1. Edit postgresdk.config.ts with your database connection");
+    if (!hasEnv) {
+      console.log("   2. Consider creating a .env file for sensitive values:");
+      console.log("      DATABASE_URL=postgres://user:pass@localhost:5432/mydb");
+      console.log("      API_KEY=your-secret-key");
+      console.log("      JWT_SECRET=your-jwt-secret");
+    }
+    console.log("   3. Run 'postgresdk generate' to create your SDK");
+    console.log(`
+\uD83D\uDCA1 Tip: The config file has detailed comments for all options.`);
+    console.log("   Uncomment the options you want to customize.");
+  } catch (error) {
+    console.error("❌ Error creating config file:", error);
+    process.exit(1);
+  }
+}
+var CONFIG_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: process.env.DATABASE_URL || "postgres://user:password@localhost:5432/mydb",
+  
+  // ========== BASIC OPTIONS ==========
+  
+  /**
+   * Database schema to introspect
+   * @default "public"
+   */
+  // schema: "public",
+  
+  /**
+   * Output directory for server-side code (routes, validators, etc.)
+   * @default "./generated/server"
+   */
+  // outServer: "./generated/server",
+  
+  /**
+   * Output directory for client SDK
+   * @default "./generated/client"
+   */
+  // outClient: "./generated/client",
+  
+  // ========== 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"
+   */
+  // softDeleteColumn: null,
+  
+  /**
+   * Maximum depth for nested relationship includes to prevent infinite loops
+   * @default 3
+   */
+  // includeDepthLimit: 3,
+  
+  /**
+   * How to handle date/timestamp columns in TypeScript
+   * - "date": Use JavaScript Date objects
+   * - "string": Use ISO 8601 strings
+   * @default "date"
+   */
+  // dateType: "date",
+  
+  // ========== 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
+  // },
+};
+`;
+var init_cli_init = () => {};
+
+// src/cli-pull.ts
+var exports_cli_pull = {};
+__export(exports_cli_pull, {
+  pullCommand: () => pullCommand
+});
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2, dirname as dirname2, resolve as resolve2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function pullCommand(args) {
+  let configPath = "postgresdk.config.ts";
+  const configIndex = args.findIndex((a) => a === "-c" || a === "--config");
+  if (configIndex !== -1 && args[configIndex + 1]) {
+    configPath = args[configIndex + 1];
+  }
+  let fileConfig = {};
+  const fullConfigPath = resolve2(process.cwd(), configPath);
+  if (existsSync2(fullConfigPath)) {
+    console.log(`\uD83D\uDCCB Loading ${configPath}`);
+    try {
+      const configUrl = pathToFileURL2(fullConfigPath).href;
+      const module = await import(configUrl);
+      const config2 = module.default || module;
+      if (config2.pull) {
+        fileConfig = config2.pull;
+      }
+    } catch (err) {
+      console.error("⚠️  Failed to load config file:", err);
+    }
+  }
+  const cliConfig = {
+    from: args.find((a) => a.startsWith("--from="))?.split("=")[1],
+    output: args.find((a) => a.startsWith("--output="))?.split("=")[1],
+    token: args.find((a) => a.startsWith("--token="))?.split("=")[1]
+  };
+  const config = {
+    output: "./src/sdk",
+    ...fileConfig,
+    ...Object.fromEntries(Object.entries(cliConfig).filter(([_, v]) => v !== undefined))
+  };
+  if (!config.from) {
+    console.error("❌ Missing API URL. Specify via --from or in postgresdk.config.ts");
+    console.error(`
+Example config file:`);
+    console.error(`export default {
+  pull: {
+    from: "https://api.company.com",
+    output: "./src/sdk"
+  }
+}`);
+    process.exit(1);
+  }
+  console.log(`\uD83D\uDD04 Pulling SDK from ${config.from}`);
+  console.log(`\uD83D\uDCC1 Output directory: ${config.output}`);
+  try {
+    const headers = config.token ? { Authorization: `Bearer ${config.token}` } : {};
+    const manifestRes = await fetch(`${config.from}/sdk/manifest`, { headers });
+    if (!manifestRes.ok) {
+      throw new Error(`Failed to fetch SDK manifest: ${manifestRes.status} ${manifestRes.statusText}`);
+    }
+    const manifest = await manifestRes.json();
+    console.log(`\uD83D\uDCE6 SDK version: ${manifest.version}`);
+    console.log(`\uD83D\uDCC5 Generated: ${manifest.generated}`);
+    console.log(`\uD83D\uDCC4 Files: ${manifest.files.length}`);
+    const sdkRes = await fetch(`${config.from}/sdk/download`, { headers });
+    if (!sdkRes.ok) {
+      throw new Error(`Failed to download SDK: ${sdkRes.status} ${sdkRes.statusText}`);
+    }
+    const sdk = await sdkRes.json();
+    for (const [path, content] of Object.entries(sdk.files)) {
+      const fullPath = join2(config.output, path);
+      await mkdir2(dirname2(fullPath), { recursive: true });
+      await writeFile2(fullPath, content, "utf-8");
+      console.log(`  ✓ ${path}`);
+    }
+    await writeFile2(join2(config.output, ".postgresdk.json"), JSON.stringify({
+      version: sdk.version,
+      generated: sdk.generated,
+      pulledFrom: config.from,
+      pulledAt: new Date().toISOString()
+    }, null, 2));
+    console.log(`✅ SDK pulled successfully to ${config.output}`);
+  } catch (err) {
+    console.error(`❌ Pull failed:`, err);
+    process.exit(1);
+  }
+}
+var init_cli_pull = () => {};
+
 // src/index.ts
 var import_config = __toESM(require_config(), 1);
 import { join } from "node:path";
@@ -1748,6 +1994,7 @@ function emitRouter(tables, hasAuth) {
 `);
   return `/* Generated. Do not edit. */
 import { Hono } from "hono";
+import { SDK_MANIFEST } from "./sdk-bundle";
 ${imports}
 ${hasAuth ? `export { authMiddleware } from "./auth";` : ""}
 
@@ -1775,7 +2022,34 @@ export function createRouter(
   deps: { pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> } }
 ): Hono {
   const router = new Hono();
+  
+  // Register table routes
 ${registrations}
+  
+  // SDK distribution endpoints
+  router.get("/sdk/manifest", (c) => {
+    return c.json({
+      version: SDK_MANIFEST.version,
+      generated: SDK_MANIFEST.generated,
+      files: Object.keys(SDK_MANIFEST.files)
+    });
+  });
+  
+  router.get("/sdk/download", (c) => {
+    return c.json(SDK_MANIFEST);
+  });
+  
+  router.get("/sdk/files/:path{.*}", (c) => {
+    const path = c.req.param("path");
+    const content = SDK_MANIFEST.files[path];
+    if (!content) {
+      return c.text("File not found", 404);
+    }
+    return c.text(content, 200, {
+      "Content-Type": "text/plain; charset=utf-8"
+    });
+  });
+  
   return router;
 }
 
@@ -1809,6 +2083,29 @@ export * from "./include-spec";
 `;
 }
 
+// src/emit-sdk-bundle.ts
+function emitSdkBundle(clientFiles) {
+  const files = {};
+  for (const file of clientFiles) {
+    const parts = file.path.split("/");
+    const clientIndex = parts.lastIndexOf("client");
+    if (clientIndex >= 0 && clientIndex < parts.length - 1) {
+      const relativePath = parts.slice(clientIndex + 1).join("/");
+      files[relativePath] = file.content;
+    }
+  }
+  const version = `1.0.0`;
+  const generated = new Date().toISOString();
+  return `/* Generated. Do not edit. */
+
+export const SDK_MANIFEST = {
+  version: "${version}",
+  generated: "${generated}",
+  files: ${JSON.stringify(files, null, 2)}
+};
+`;
+}
+
 // src/types.ts
 function normalizeAuthConfig(input) {
   if (!input)
@@ -1915,6 +2212,11 @@ async function generate(configPath) {
     path: join(serverDir, "router.ts"),
     content: emitRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none")
   });
+  const clientFiles = files.filter((f) => f.path.includes(clientDir));
+  files.push({
+    path: join(serverDir, "sdk-bundle.ts"),
+    content: emitSdkBundle(clientFiles)
+  });
   console.log("✍️  Writing files...");
   await writeFiles(files);
   console.log(`✅ Generated ${files.length} files`);
@@ -1924,41 +2226,75 @@ async function generate(configPath) {
 
 // src/cli.ts
 var import_config2 = __toESM(require_config(), 1);
-import { resolve } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { dirname as dirname3, join as join3 } from "node:path";
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = dirname2(__filename2);
-var packageJson = JSON.parse(readFileSync(join2(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = dirname3(__filename2);
+var packageJson = JSON.parse(readFileSync(join3(__dirname2, "../package.json"), "utf-8"));
 var VERSION = packageJson.version;
 var args = process.argv.slice(2);
-if (args.includes("--version") || args.includes("-v")) {
+var command = args[0];
+if (args.includes("--version") || args.includes("-v") || command === "version") {
   console.log(`postgresdk v${VERSION}`);
   process.exit(0);
 }
-if (args.includes("--help") || args.includes("-h")) {
+if (args.includes("--help") || args.includes("-h") || command === "help" || !command) {
   console.log(`
 postgresdk - Generate typed SDK from PostgreSQL
 
 Usage:
-  postgresdk [options]
+  postgresdk <command> [options]
+
+Commands:
+  init                 Create a postgresdk.config.ts file
+  generate             Generate SDK from database
+  pull                 Pull SDK from API endpoint
+  version              Show version
+  help                 Show help
+
+Init Options:
+  (no options)
 
-Options:
+Generate Options:
   -c, --config <path>  Path to config file (default: postgresdk.config.ts)
-  -v, --version        Show version
-  -h, --help           Show help
+
+Pull Options:
+  --from <url>         API URL to pull SDK from
+  --output <path>      Output directory (default: ./src/sdk)
+  --token <token>      Authentication token
+  -c, --config <path>  Path to config file with pull settings
+
+Examples:
+  postgresdk init                        # Create config file
+  postgresdk generate                    # Generate using postgresdk.config.ts
+  postgresdk generate -c custom.config.ts
+  postgresdk pull --from=https://api.com --output=./src/sdk
+  postgresdk pull                        # Pull using config file
 `);
   process.exit(0);
 }
-var configPath = "postgresdk.config.ts";
-var configIndex = args.findIndex((a) => a === "-c" || a === "--config");
-if (configIndex !== -1 && args[configIndex + 1]) {
-  configPath = args[configIndex + 1];
-}
-try {
-  await generate(resolve(process.cwd(), configPath));
-} catch (err) {
-  console.error("❌ Generation failed:", err);
+if (command === "init") {
+  const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_cli_init(), exports_cli_init));
+  await initCommand2(args.slice(1));
+} else if (command === "generate") {
+  let configPath = "postgresdk.config.ts";
+  const configIndex = args.findIndex((a) => a === "-c" || a === "--config");
+  if (configIndex !== -1 && args[configIndex + 1]) {
+    configPath = args[configIndex + 1];
+  }
+  try {
+    await generate(resolve3(process.cwd(), configPath));
+  } catch (err) {
+    console.error("❌ Generation failed:", err);
+    process.exit(1);
+  }
+} else if (command === "pull") {
+  const { pullCommand: pullCommand2 } = await Promise.resolve().then(() => (init_cli_pull(), exports_cli_pull));
+  await pullCommand2(args.slice(1));
+} else {
+  console.error(`❌ Unknown command: ${command}`);
+  console.error(`Run 'postgresdk help' for usage information`);
   process.exit(1);
 }

package/dist/emit-sdk-bundle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a bundle containing all client SDK files as a single module
+ * that can be served by the API
+ */
+export declare function emitSdkBundle(clientFiles: {
+    path: string;
+    content: string;
+}[]): string;

package/dist/index.js

@@ -16,6 +16,16 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/dotenv/package.json
@@ -1747,6 +1757,7 @@ function emitRouter(tables, hasAuth) {
 `);
   return `/* Generated. Do not edit. */
 import { Hono } from "hono";
+import { SDK_MANIFEST } from "./sdk-bundle";
 ${imports}
 ${hasAuth ? `export { authMiddleware } from "./auth";` : ""}
 
@@ -1774,7 +1785,34 @@ export function createRouter(
   deps: { pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> } }
 ): Hono {
   const router = new Hono();
+  
+  // Register table routes
 ${registrations}
+  
+  // SDK distribution endpoints
+  router.get("/sdk/manifest", (c) => {
+    return c.json({
+      version: SDK_MANIFEST.version,
+      generated: SDK_MANIFEST.generated,
+      files: Object.keys(SDK_MANIFEST.files)
+    });
+  });
+  
+  router.get("/sdk/download", (c) => {
+    return c.json(SDK_MANIFEST);
+  });
+  
+  router.get("/sdk/files/:path{.*}", (c) => {
+    const path = c.req.param("path");
+    const content = SDK_MANIFEST.files[path];
+    if (!content) {
+      return c.text("File not found", 404);
+    }
+    return c.text(content, 200, {
+      "Content-Type": "text/plain; charset=utf-8"
+    });
+  });
+  
   return router;
 }
 
@@ -1808,6 +1846,29 @@ export * from "./include-spec";
 `;
 }
 
+// src/emit-sdk-bundle.ts
+function emitSdkBundle(clientFiles) {
+  const files = {};
+  for (const file of clientFiles) {
+    const parts = file.path.split("/");
+    const clientIndex = parts.lastIndexOf("client");
+    if (clientIndex >= 0 && clientIndex < parts.length - 1) {
+      const relativePath = parts.slice(clientIndex + 1).join("/");
+      files[relativePath] = file.content;
+    }
+  }
+  const version = `1.0.0`;
+  const generated = new Date().toISOString();
+  return `/* Generated. Do not edit. */
+
+export const SDK_MANIFEST = {
+  version: "${version}",
+  generated: "${generated}",
+  files: ${JSON.stringify(files, null, 2)}
+};
+`;
+}
+
 // src/types.ts
 function normalizeAuthConfig(input) {
   if (!input)
@@ -1914,6 +1975,11 @@ async function generate(configPath) {
     path: join(serverDir, "router.ts"),
     content: emitRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none")
   });
+  const clientFiles = files.filter((f) => f.path.includes(clientDir));
+  files.push({
+    path: join(serverDir, "sdk-bundle.ts"),
+    content: emitSdkBundle(clientFiles)
+  });
   console.log("✍️  Writing files...");
   await writeFiles(files);
   console.log(`✅ Generated ${files.length} files`);

package/dist/types.d.ts

@@ -27,5 +27,11 @@ export interface Config {
     includeDepthLimit?: number;
     dateType?: "date" | "string";
     auth?: AuthConfigInput;
+    pull?: PullConfig;
+}
+export interface PullConfig {
+    from: string;
+    output?: string;
+    token?: string;
 }
 export declare function normalizeAuthConfig(input: AuthConfigInput | undefined): AuthConfig | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.1.2-alpha.4",
+  "version": "0.2.0",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {
@@ -22,7 +22,10 @@
   },
   "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",
-    "test": "bun test/test-gen.ts",
+    "test": "bun test:init && bun test:gen && bun test:pull",
+    "test:init": "bun test/test-init.ts",
+    "test:gen": "bun test/test-gen.ts",
+    "test:pull": "bun test/test-pull.ts",
     "prepublishOnly": "npm run build",
     "publish:patch": "./publish.sh",
     "publish:minor": "./publish.sh",