postgresdk 0.18.2 → 0.18.4

package/dist/cache.d.ts

@@ -14,6 +14,7 @@ export interface CacheData {
 }
 /**
  * Compute a deterministic hash of the schema and config
+ * Includes postgresdk version to trigger regeneration on upgrades
  */
 export declare function computeSchemaHash(model: Model, config: Config): string;
 /**

package/dist/cli.js

@@ -1689,10 +1689,11 @@ var init_emit_sdk_contract = __esm(() => {
 // src/cache.ts
 import { createHash } from "crypto";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, appendFile } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 function computeSchemaHash(model, config) {
   const payload = {
+    version: POSTGRESDK_VERSION,
     schema: model.schema,
     tables: model.tables,
     enums: model.enums,
@@ -1780,7 +1781,11 @@ async function appendToHistory(entry, baseDir) {
 ${formattedEntry}`, "utf-8");
   }
 }
-var init_cache = () => {};
+var __dirname = "/workspace/src", packageJson, POSTGRESDK_VERSION;
+var init_cache = __esm(() => {
+  packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+  POSTGRESDK_VERSION = packageJson.version;
+});
 
 // src/cli-config-utils.ts
 function extractConfigFields(configContent) {
@@ -2201,7 +2206,7 @@ var exports_cli_init = {};
 __export(exports_cli_init, {
   initCommand: () => initCommand
 });
-import { existsSync as existsSync3, writeFileSync, readFileSync, copyFileSync } from "fs";
+import { existsSync as existsSync3, writeFileSync, readFileSync as readFileSync2, copyFileSync } from "fs";
 import { resolve } from "path";
 import prompts from "prompts";
 async function initCommand(args) {
@@ -2219,7 +2224,7 @@ async function initCommand(args) {
     }
     console.log(`⚠️  Found existing postgresdk.config.ts
 `);
-    const existingContent = readFileSync(configPath, "utf-8");
+    const existingContent = readFileSync2(configPath, "utf-8");
     const existingFields = extractConfigFields(existingContent);
     console.log("\uD83D\uDCCB Existing configuration detected:");
     existingFields.forEach((field) => {
@@ -3780,11 +3785,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}?\${query}\` : this.resource;
     return this.post<Select${Type}<TJsonb>>(url, data);
   }` : `  /**
+   * Create a new ${table.name} record with field selection
+   * @param data - The data to insert
+   * @param options - Select specific fields to return
+   * @returns The created record with only selected fields
+   */
+  async create(data: Insert${Type}, options: { select: string[] }): Promise<Partial<Select${Type}>>;
+  /**
+   * Create a new ${table.name} record with field exclusion
+   * @param data - The data to insert
+   * @param options - Exclude specific fields from return
+   * @returns The created record without excluded fields
+   */
+  async create(data: Insert${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}>>;
+  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
-   * @param options - Optional select/exclude for returned fields
-   * @returns The created record
+   * @returns The created record with all fields
    */
+  async create(data: Insert${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}>;
   async create(
     data: Insert${Type},
     options?: { select?: string[]; exclude?: string[] }
@@ -3818,11 +3837,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.get<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Get a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The record with only selected fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Get a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The record without excluded fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The record if found, null otherwise
+   * @returns The record with all fields if found, null otherwise
    */
+  async getByPk(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async getByPk(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -3873,21 +3906,70 @@ ${hasJsonbColumns ? `  /**
   }): Promise<PaginatedResponse<(Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
     return this.post<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }` : `  /**
+   * List ${table.name} records with field selection
+   * @param params - Query parameters with select
+   * @returns Paginated results with only selected fields
+   */
+  async list(params: {
+    select: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
+   * List ${table.name} records with field exclusion
+   * @param params - Query parameters with exclude
+   * @returns Paginated results without excluded fields
+   */
+  async list(params: {
+    exclude: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
-   * @param params.select - Array of field names to include in response
-   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (see listWith* methods for typed includes)
-   * @returns Paginated results with data, total count, and hasMore flag
-   * @example
-   * // With select:
-   * const users = await client.list({ select: ['id', 'email'] });
+   * @returns Paginated results with all fields
    */
+  async list(params?: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
   async list(params?: {
     include?: any;
     select?: string[];
@@ -3903,7 +3985,7 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<(Select${Type} | Partial<Select${Type}>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<Select${Type} | Partial<Select${Type}>>> {
     return this.post<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }`}
 
@@ -3930,12 +4012,28 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.patch<Select${Type}<TJsonb> | null>(url, patch);
   }` : `  /**
+   * Update a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Select specific fields to return
+   * @returns The updated record with only selected fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Update a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Exclude specific fields from return
+   * @returns The updated record without excluded fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
-   * @param options - Optional select/exclude for returned fields
-   * @returns The updated record if found, null otherwise
+   * @returns The updated record with all fields if found, null otherwise
    */
+  async update(pk: ${pkType}, patch: Update${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async update(
     pk: ${pkType},
     patch: Update${Type},
@@ -3971,11 +4069,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.del<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Delete a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The deleted record with only selected fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Delete a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The deleted record without excluded fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The deleted record if found, null otherwise
+   * @returns The deleted record with all fields if found, null otherwise
    */
+  async delete(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async delete(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -7192,13 +7304,13 @@ async function generate(configPath) {
 // src/cli.ts
 var import_config2 = __toESM(require_config(), 1);
 import { resolve as resolve3 } from "node:path";
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname as dirname4, join as join4 } from "node:path";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname4(__filename2);
-var packageJson = JSON.parse(readFileSync2(join4(__dirname2, "../package.json"), "utf-8"));
-var VERSION = packageJson.version;
+var packageJson2 = JSON.parse(readFileSync3(join4(__dirname2, "../package.json"), "utf-8"));
+var VERSION = packageJson2.version;
 var args = process.argv.slice(2);
 var command = args[0];
 if (args.includes("--version") || args.includes("-v") || command === "version") {

package/dist/index.js

@@ -1688,10 +1688,11 @@ var init_emit_sdk_contract = __esm(() => {
 // src/cache.ts
 import { createHash } from "crypto";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, appendFile } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 function computeSchemaHash(model, config) {
   const payload = {
+    version: POSTGRESDK_VERSION,
     schema: model.schema,
     tables: model.tables,
     enums: model.enums,
@@ -1779,7 +1780,11 @@ async function appendToHistory(entry, baseDir) {
 ${formattedEntry}`, "utf-8");
   }
 }
-var init_cache = () => {};
+var __dirname = "/workspace/src", packageJson, POSTGRESDK_VERSION;
+var init_cache = __esm(() => {
+  packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
+  POSTGRESDK_VERSION = packageJson.version;
+});
 
 // src/index.ts
 var import_config = __toESM(require_config(), 1);
@@ -2801,11 +2806,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}?\${query}\` : this.resource;
     return this.post<Select${Type}<TJsonb>>(url, data);
   }` : `  /**
+   * Create a new ${table.name} record with field selection
+   * @param data - The data to insert
+   * @param options - Select specific fields to return
+   * @returns The created record with only selected fields
+   */
+  async create(data: Insert${Type}, options: { select: string[] }): Promise<Partial<Select${Type}>>;
+  /**
+   * Create a new ${table.name} record with field exclusion
+   * @param data - The data to insert
+   * @param options - Exclude specific fields from return
+   * @returns The created record without excluded fields
+   */
+  async create(data: Insert${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}>>;
+  /**
    * Create a new ${table.name} record
    * @param data - The data to insert
-   * @param options - Optional select/exclude for returned fields
-   * @returns The created record
+   * @returns The created record with all fields
    */
+  async create(data: Insert${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type}>;
   async create(
     data: Insert${Type},
     options?: { select?: string[]; exclude?: string[] }
@@ -2839,11 +2858,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.get<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Get a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The record with only selected fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Get a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The record without excluded fields if found, null otherwise
+   */
+  async getByPk(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Get a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The record if found, null otherwise
+   * @returns The record with all fields if found, null otherwise
    */
+  async getByPk(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async getByPk(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }
@@ -2894,21 +2927,70 @@ ${hasJsonbColumns ? `  /**
   }): Promise<PaginatedResponse<(Select${Type}<TJsonb> | Partial<Select${Type}<TJsonb>>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
     return this.post<PaginatedResponse<Select${Type}<TJsonb>${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }` : `  /**
+   * List ${table.name} records with field selection
+   * @param params - Query parameters with select
+   * @returns Paginated results with only selected fields
+   */
+  async list(params: {
+    select: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
+   * List ${table.name} records with field exclusion
+   * @param params - Query parameters with exclude
+   * @returns Paginated results without excluded fields
+   */
+  async list(params: {
+    exclude: string[];
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Partial<Select${Type}>${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
+  /**
    * List ${table.name} records with pagination and filtering
    * @param params - Query parameters
    * @param params.where - Filter conditions using operators like $eq, $gt, $in, $like, etc.
-   * @param params.select - Array of field names to include in response
-   * @param params.exclude - Array of field names to exclude from response (mutually exclusive with select)
    * @param params.orderBy - Column(s) to sort by
    * @param params.order - Sort direction(s): "asc" or "desc"
    * @param params.limit - Maximum number of records to return (default: 50, max: 1000)
    * @param params.offset - Number of records to skip for pagination
    * @param params.include - Related records to include (see listWith* methods for typed includes)
-   * @returns Paginated results with data, total count, and hasMore flag
-   * @example
-   * // With select:
-   * const users = await client.list({ select: ['id', 'email'] });
+   * @returns Paginated results with all fields
    */
+  async list(params?: {
+    include?: any;
+    limit?: number;
+    offset?: number;
+    where?: Where<Select${Type}>;${hasVectorColumns ? `
+    vector?: {
+      field: string;
+      query: number[];
+      metric?: "cosine" | "l2" | "inner";
+      maxDistance?: number;
+    };` : ""}
+    orderBy?: string | string[];
+    order?: "asc" | "desc" | ("asc" | "desc")[];
+  }): Promise<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>;
   async list(params?: {
     include?: any;
     select?: string[];
@@ -2924,7 +3006,7 @@ ${hasJsonbColumns ? `  /**
     };` : ""}
     orderBy?: string | string[];
     order?: "asc" | "desc" | ("asc" | "desc")[];
-  }): Promise<PaginatedResponse<(Select${Type} | Partial<Select${Type}>)${hasVectorColumns ? " & { _distance?: number }" : ""}>> {
+  }): Promise<PaginatedResponse<Select${Type} | Partial<Select${Type}>>> {
     return this.post<PaginatedResponse<Select${Type}${hasVectorColumns ? " & { _distance?: number }" : ""}>>(\`\${this.resource}/list\`, params ?? {});
   }`}
 
@@ -2951,12 +3033,28 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.patch<Select${Type}<TJsonb> | null>(url, patch);
   }` : `  /**
+   * Update a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Select specific fields to return
+   * @returns The updated record with only selected fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Update a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param patch - Partial data to update
+   * @param options - Exclude specific fields from return
+   * @returns The updated record without excluded fields if found, null otherwise
+   */
+  async update(pk: ${pkType}, patch: Update${Type}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Update a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
    * @param patch - Partial data to update
-   * @param options - Optional select/exclude for returned fields
-   * @returns The updated record if found, null otherwise
+   * @returns The updated record with all fields if found, null otherwise
    */
+  async update(pk: ${pkType}, patch: Update${Type}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async update(
     pk: ${pkType},
     patch: Update${Type},
@@ -2992,11 +3090,25 @@ ${hasJsonbColumns ? `  /**
     const url = query ? \`\${this.resource}/\${path}?\${query}\` : \`\${this.resource}/\${path}\`;
     return this.del<Select${Type}<TJsonb> | null>(url);
   }` : `  /**
+   * Delete a ${table.name} record by primary key with field selection
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Select specific fields to return
+   * @returns The deleted record with only selected fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { select: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
+   * Delete a ${table.name} record by primary key with field exclusion
+   * @param pk - The primary key value${hasCompositePk ? "s" : ""}
+   * @param options - Exclude specific fields from return
+   * @returns The deleted record without excluded fields if found, null otherwise
+   */
+  async delete(pk: ${pkType}, options: { exclude: string[] }): Promise<Partial<Select${Type}> | null>;
+  /**
    * Delete a ${table.name} record by primary key
    * @param pk - The primary key value${hasCompositePk ? "s" : ""}
-   * @param options - Optional select/exclude for returned fields
-   * @returns The deleted record if found, null otherwise
+   * @returns The deleted record with all fields if found, null otherwise
    */
+  async delete(pk: ${pkType}, options?: Omit<{ select?: string[]; exclude?: string[] }, 'select' | 'exclude'>): Promise<Select${Type} | null>;
   async delete(
     pk: ${pkType},
     options?: { select?: string[]; exclude?: string[] }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postgresdk",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "Generate a typed server/client SDK from a Postgres schema (includes, Zod, Hono).",
   "type": "module",
   "bin": {