postgresdk 0.1.2-alpha.3 → 0.2.0

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";
@@ -958,13 +1204,116 @@ function emitClient(table) {
   const pkType = hasCompositePk ? `{ ${safePk.map((c) => `${c}: string`).join("; ")} }` : `string`;
   const pkPathExpr = hasCompositePk ? safePk.map((c) => `pk.${c}`).join(` + "/" + `) : `pk`;
   return `/* Generated. Do not edit. */
+import { BaseClient } from "./base-client";
 import type { ${Type}IncludeSpec } from "./include-spec";
 import type { Insert${Type}, Update${Type}, Select${Type} } from "./types/${table.name}";
 
-type HeaderMap = Record<string, string>;
-type AuthHeadersProvider = () => Promise<HeaderMap> | HeaderMap;
+/**
+ * Client for ${table.name} table operations
+ */
+export class ${Type}Client extends BaseClient {
+  private readonly resource = "/v1/${table.name}";
+
+  async create(data: Insert${Type}): Promise<Select${Type}> {
+    return this.post<Select${Type}>(this.resource, data);
+  }
 
-type AuthConfig =
+  async getByPk(pk: ${pkType}): Promise<Select${Type} | null> {
+    const path = ${pkPathExpr};
+    return this.get<Select${Type} | null>(\`\${this.resource}/\${path}\`);
+  }
+
+  async list(params?: { 
+    include?: ${Type}IncludeSpec; 
+    limit?: number; 
+    offset?: number;
+    where?: any;
+    orderBy?: string;
+    order?: "asc" | "desc";
+  }): Promise<Select${Type}[]> {
+    return this.post<Select${Type}[]>(\`\${this.resource}/list\`, params ?? {});
+  }
+
+  async update(pk: ${pkType}, patch: Update${Type}): Promise<Select${Type} | null> {
+    const path = ${pkPathExpr};
+    return this.patch<Select${Type} | null>(\`\${this.resource}/\${path}\`, patch);
+  }
+
+  async delete(pk: ${pkType}): Promise<Select${Type} | null> {
+    const path = ${pkPathExpr};
+    return this.del<Select${Type} | null>(\`\${this.resource}/\${path}\`);
+  }
+}
+`;
+}
+function emitClientIndex(tables) {
+  let out = `/* Generated. Do not edit. */
+`;
+  out += `import { BaseClient, AuthConfig } from "./base-client";
+`;
+  for (const t of tables) {
+    out += `import { ${pascal(t.name)}Client } from "./${t.name}";
+`;
+  }
+  out += `
+// Re-export auth types for convenience
+`;
+  out += `export type { AuthConfig as SDKAuth, AuthConfig, HeaderMap, AuthHeadersProvider } from "./base-client";
+
+`;
+  out += `/**
+`;
+  out += ` * Main SDK class that provides access to all table clients
+`;
+  out += ` */
+`;
+  out += `export class SDK {
+`;
+  for (const t of tables) {
+    out += `  public ${t.name}: ${pascal(t.name)}Client;
+`;
+  }
+  out += `
+  constructor(cfg: { baseUrl: string; fetch?: typeof fetch; auth?: AuthConfig }) {
+`;
+  out += `    const f = cfg.fetch ?? fetch;
+`;
+  for (const t of tables) {
+    out += `    this.${t.name} = new ${pascal(t.name)}Client(cfg.baseUrl, f, cfg.auth);
+`;
+  }
+  out += `  }
+`;
+  out += `}
+
+`;
+  out += `// Export individual table clients
+`;
+  for (const t of tables) {
+    out += `export { ${pascal(t.name)}Client } from "./${t.name}";
+`;
+  }
+  out += `
+// Export base client for custom extensions
+`;
+  out += `export { BaseClient } from "./base-client";
+`;
+  out += `
+// Export include specifications
+`;
+  out += `export * from "./include-spec";
+`;
+  return out;
+}
+
+// src/emit-base-client.ts
+function emitBaseClient() {
+  return `/* Generated. Do not edit. */
+
+export type HeaderMap = Record<string, string>;
+export type AuthHeadersProvider = () => Promise<HeaderMap> | HeaderMap;
+
+export type AuthConfig =
   | AuthHeadersProvider
   | {
       apiKey?: string;
@@ -976,14 +1325,18 @@ type AuthConfig =
       headers?: AuthHeadersProvider;
     };
 
-export class ${Type}Client {
+/**
+ * Base client class with shared authentication and request handling logic.
+ * All table-specific clients extend this class.
+ */
+export abstract class BaseClient {
   constructor(
-    private baseUrl: string,
-    private fetchFn: typeof fetch = fetch,
-    private auth?: AuthConfig
+    protected baseUrl: string,
+    protected fetchFn: typeof fetch = fetch,
+    protected auth?: AuthConfig
   ) {}
 
-  private async authHeaders(): Promise<HeaderMap> {
+  protected async authHeaders(): Promise<HeaderMap> {
     if (!this.auth) return {};
     if (typeof this.auth === "function") {
       const h = await this.auth();
@@ -1009,129 +1362,91 @@ export class ${Type}Client {
     return out;
   }
 
-  private async headers(json = false) {
+  protected async headers(json = false): Promise<HeaderMap> {
     const extra = await this.authHeaders();
     return json ? { "Content-Type": "application/json", ...extra } : extra;
   }
 
-  private async okOrThrow(res: Response, action: string) {
+  protected async okOrThrow(res: Response, action: string, entity: string): Promise<void> {
     if (!res.ok) {
       let detail = "";
       try { detail = await res.text(); } catch {}
-      throw new Error(\`\${action} ${table.name} failed: \${res.status} \${detail}\`);
+      throw new Error(\`\${action} \${entity} failed: \${res.status} \${detail}\`);
     }
   }
 
-  async create(data: Insert${Type}): Promise<Select${Type}> {
-    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}\`, {
+  /**
+   * Make a POST request
+   */
+  protected async post<T>(path: string, body?: any): Promise<T> {
+    const res = await this.fetchFn(\`\${this.baseUrl}\${path}\`, {
       method: "POST",
       headers: await this.headers(true),
-      body: JSON.stringify(data),
+      body: JSON.stringify(body),
     });
-    await this.okOrThrow(res, "create");
-    return (await res.json()) as Select${Type};
+    
+    // Handle 404 specially for operations that might return null
+    if (res.status === 404) {
+      return null as T;
+    }
+    
+    await this.okOrThrow(res, "POST", path);
+    return (await res.json()) as T;
   }
 
-  async getByPk(pk: ${pkType}): Promise<Select${Type} | null> {
-    const path = ${pkPathExpr};
-    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/\${path}\`, {
+  /**
+   * Make a GET request
+   */
+  protected async get<T>(path: string): Promise<T> {
+    const res = await this.fetchFn(\`\${this.baseUrl}\${path}\`, {
       headers: await this.headers(),
     });
-    if (res.status === 404) return null;
-    await this.okOrThrow(res, "get");
-    return (await res.json()) as Select${Type};
-  }
-
-  async list(params?: { include?: ${Type}IncludeSpec; limit?: number; offset?: number }): Promise<Select${Type}[]> {
-    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/list\`, {
-      method: "POST",
-      headers: await this.headers(true),
-      body: JSON.stringify(params ?? {}),
-    });
-    await this.okOrThrow(res, "list");
-    return (await res.json()) as Select${Type}[];
+    
+    if (res.status === 404) {
+      return null as T;
+    }
+    
+    await this.okOrThrow(res, "GET", path);
+    return (await res.json()) as T;
   }
 
-  async update(pk: ${pkType}, patch: Update${Type}): Promise<Select${Type} | null> {
-    const path = ${pkPathExpr};
-    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/\${path}\`, {
+  /**
+   * Make a PATCH request
+   */
+  protected async patch<T>(path: string, body?: any): Promise<T> {
+    const res = await this.fetchFn(\`\${this.baseUrl}\${path}\`, {
       method: "PATCH",
       headers: await this.headers(true),
-      body: JSON.stringify(patch),
+      body: JSON.stringify(body),
     });
-    if (res.status === 404) return null;
-    await this.okOrThrow(res, "update");
-    return (await res.json()) as Select${Type};
+    
+    if (res.status === 404) {
+      return null as T;
+    }
+    
+    await this.okOrThrow(res, "PATCH", path);
+    return (await res.json()) as T;
   }
 
-  async delete(pk: ${pkType}): Promise<Select${Type} | null> {
-    const path = ${pkPathExpr};
-    const res = await this.fetchFn(\`\${this.baseUrl}/v1/${table.name}/\${path}\`, {
+  /**
+   * Make a DELETE request
+   */
+  protected async del<T>(path: string): Promise<T> {
+    const res = await this.fetchFn(\`\${this.baseUrl}\${path}\`, {
       method: "DELETE",
       headers: await this.headers(),
     });
-    if (res.status === 404) return null;
-    await this.okOrThrow(res, "delete");
-    return (await res.json()) as Select${Type};
+    
+    if (res.status === 404) {
+      return null as T;
+    }
+    
+    await this.okOrThrow(res, "DELETE", path);
+    return (await res.json()) as T;
   }
 }
 `;
 }
-function emitClientIndex(tables) {
-  let out = `/* Generated. Do not edit. */
-`;
-  for (const t of tables) {
-    out += `import { ${pascal(t.name)}Client } from "./${t.name}";
-`;
-  }
-  out += `
-export type SDKAuthHeadersProvider = () => Promise<Record<string,string>> | Record<string,string>;
-`;
-  out += `export type SDKAuth =
-`;
-  out += `  | SDKAuthHeadersProvider
-`;
-  out += `  | {
-`;
-  out += `      apiKey?: string;
-`;
-  out += `      /** defaults to "x-api-key" */
-`;
-  out += `      apiKeyHeader?: string;
-`;
-  out += `      jwt?: string | (() => Promise<string>);
-`;
-  out += `      headers?: SDKAuthHeadersProvider;
-`;
-  out += `    };
-
-`;
-  out += `export class SDK {
-`;
-  for (const t of tables) {
-    out += `  public ${t.name}: ${pascal(t.name)}Client;
-`;
-  }
-  out += `
-  constructor(cfg: { baseUrl: string; fetch?: typeof fetch; auth?: SDKAuth }) {
-`;
-  out += `    const f = cfg.fetch ?? fetch;
-`;
-  for (const t of tables) {
-    out += `    this.${t.name} = new ${pascal(t.name)}Client(cfg.baseUrl, f, cfg.auth);
-`;
-  }
-  out += `  }
-`;
-  out += `}
-`;
-  for (const t of tables)
-    out += `export { ${pascal(t.name)}Client } from "./${t.name}";
-`;
-  out += `export * from "./include-spec";
-`;
-  return out;
-}
 
 // src/emit-include-loader.ts
 function emitIncludeLoader(graph, model, maxDepth) {
@@ -1679,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";` : ""}
 
@@ -1706,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;
 }
 
@@ -1740,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)
@@ -1804,6 +2170,7 @@ async function generate(configPath) {
   const includeSpec = emitIncludeSpec(graph);
   files.push({ path: join(serverDir, "include-spec.ts"), content: includeSpec });
   files.push({ path: join(clientDir, "include-spec.ts"), content: includeSpec });
+  files.push({ path: join(clientDir, "base-client.ts"), content: emitBaseClient() });
   files.push({
     path: join(serverDir, "include-builder.ts"),
     content: emitIncludeBuilder(graph, cfg.includeDepthLimit || 3)
@@ -1845,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`);
@@ -1854,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
 
-Options:
+Init Options:
+  (no 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);
 }