postgresdk 0.1.2-alpha.3 → 0.2.0

package/dist/emit-base-client.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Emits the BaseClient class that all table-specific clients will extend.
+ * Contains all shared logic for auth, headers, and HTTP operations.
+ */
+export declare function emitBaseClient(): string;

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
@@ -957,13 +967,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);
+  }
+
+  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);
+  }
 
-type AuthConfig =
+  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;
@@ -975,14 +1088,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();
@@ -1008,129 +1125,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) {
@@ -1678,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";` : ""}
 
@@ -1705,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;
 }
 
@@ -1739,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)
@@ -1803,6 +1933,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)
@@ -1844,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.3",
+  "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",