postgresdk 0.3.0 → 0.5.1-alpha.0

package/dist/index.js

@@ -772,8 +772,8 @@ export type Update${Type} = z.infer<typeof Update${Type}Schema>;
 `;
 }
 
-// src/emit-routes.ts
-function emitRoutes(table, _graph, opts) {
+// src/emit-routes-hono.ts
+function emitHonoRoutes(table, _graph, opts) {
   const fileTableName = table.name;
   const Type = pascal(table.name);
   const rawPk = table.pk;
@@ -782,34 +782,36 @@ function emitRoutes(table, _graph, opts) {
   const hasCompositePk = safePkCols.length > 1;
   const pkPath = hasCompositePk ? safePkCols.map((c) => `:${c}`).join("/") : `:${safePkCols[0]}`;
   const softDel = opts.softDeleteColumn && table.columns.some((c) => c.name === opts.softDeleteColumn) ? opts.softDeleteColumn : null;
-  const wherePkSql = hasCompositePk ? safePkCols.map((c, i) => `"${c}" = $${i + 1}`).join(" AND ") : `"${safePkCols[0]}" = $1`;
   const getPkParams = hasCompositePk ? `const pkValues = [${safePkCols.map((c) => `c.req.param("${c}")`).join(", ")}];` : `const pkValues = [c.req.param("${safePkCols[0]}")];`;
-  const updateSetSql = hasCompositePk ? `Object.keys(updateData).map((k, i) => \`"\${k}" = $\${i + ${safePkCols.length} + 1}\`).join(", ")` : `Object.keys(updateData).map((k, i) => \`"\${k}" = $\${i + 2}\`).join(", ")`;
-  const pkFilter = safePkCols.length ? `const updateData = Object.fromEntries(Object.entries(parsed.data).filter(([k]) => !new Set(${JSON.stringify(safePkCols)}).has(k)));` : `const updateData = parsed.data;`;
   const hasAuth = opts.authStrategy && opts.authStrategy !== "none";
-  const authImport = hasAuth ? `import { authMiddleware } from "../auth";` : "";
+  const ext = opts.useJsExtensions ? ".js" : "";
+  const authImport = hasAuth ? `import { authMiddleware } from "../auth${ext}";` : "";
   return `/* Generated. Do not edit. */
 import { Hono } from "hono";
 import { z } from "zod";
-import { Insert${Type}Schema, Update${Type}Schema } from "../zod/${fileTableName}";
-import { loadIncludes } from "../include-loader";
+import { Insert${Type}Schema, Update${Type}Schema } from "../zod/${fileTableName}${ext}";
+import { loadIncludes } from "../include-loader${ext}";
+import * as coreOps from "../core/operations${ext}";
 ${authImport}
 
-const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
-const log = {
-  debug: (...args: any[]) => { if (DEBUG) console.debug("[sdk]", ...args); },
-  error: (...args: any[]) => console.error("[sdk]", ...args),
-};
-
 const listSchema = z.object({
-  include: z.any().optional(),         // TODO: typed include spec in later pass
+  include: z.any().optional(),
   limit: z.number().int().positive().max(100).optional(),
   offset: z.number().int().min(0).optional(),
-  orderBy: z.any().optional()          // TODO: typed orderBy in a later pass
+  orderBy: z.any().optional()
 });
 
 export function register${Type}Routes(app: Hono, deps: { pg: { query: (text: string, params?: any[]) => Promise<{ rows: any[] }> } }) {
   const base = "/v1/${fileTableName}";
+  
+  // Create operation context
+  const ctx: coreOps.OperationContext = {
+    pg: deps.pg,
+    table: "${fileTableName}",
+    pkColumns: ${JSON.stringify(safePkCols)},
+    softDeleteColumn: ${softDel ? `"${softDel}"` : "null"},
+    includeDepthLimit: ${opts.includeDepthLimit}
+  };
 ${hasAuth ? `
   // \uD83D\uDD10 Auth: protect all routes for this table
   app.use(base, authMiddleware);
@@ -817,142 +819,114 @@ ${hasAuth ? `
 
   // CREATE
   app.post(base, async (c) => {
-    try {
-      const body = await c.req.json().catch(() => ({}));
-      log.debug("POST ${fileTableName} body:", body);
-      const parsed = Insert${Type}Schema.safeParse(body);
-      if (!parsed.success) {
-        const issues = parsed.error.flatten();
-        log.debug("POST ${fileTableName} invalid:", issues);
-        return c.json({ error: "Invalid body", issues }, 400);
-      }
-
-      const data = parsed.data;
-      const cols = Object.keys(data);
-      const vals = Object.values(data);
-      if (!cols.length) return c.json({ error: "No fields provided" }, 400);
-
-      const placeholders = cols.map((_, i) => '$' + (i + 1)).join(", ");
-      const text = \`INSERT INTO "${fileTableName}" (\${cols.map(c => '"' + c + '"').join(", ")})
-                     VALUES (\${placeholders})
-                     RETURNING *\`;
-      log.debug("SQL:", text, "vals:", vals);
-      const { rows } = await deps.pg.query(text, vals);
-      return c.json(rows[0] ?? null, rows[0] ? 201 : 500);
-    } catch (e: any) {
-      log.error("POST ${fileTableName} error:", e?.stack ?? e);
-      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    const body = await c.req.json().catch(() => ({}));
+    const parsed = Insert${Type}Schema.safeParse(body);
+    
+    if (!parsed.success) {
+      const issues = parsed.error.flatten();
+      return c.json({ error: "Invalid body", issues }, 400);
+    }
+    
+    const result = await coreOps.createRecord(ctx, parsed.data);
+    
+    if (result.error) {
+      return c.json({ error: result.error }, result.status as any);
     }
+    
+    return c.json(result.data, result.status as any);
   });
 
   // GET BY PK
   app.get(\`\${base}/${pkPath}\`, async (c) => {
-    try {
-      ${getPkParams}
-      const text = \`SELECT * FROM "${fileTableName}" WHERE ${wherePkSql} LIMIT 1\`;
-      log.debug("GET ${fileTableName} by PK:", pkValues, "SQL:", text);
-      const { rows } = await deps.pg.query(text, pkValues);
-      if (!rows[0]) return c.json(null, 404);
-      return c.json(rows[0]);
-    } catch (e: any) {
-      log.error("GET ${fileTableName} error:", e?.stack ?? e);
-      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    ${getPkParams}
+    const result = await coreOps.getByPk(ctx, pkValues);
+    
+    if (result.error) {
+      return c.json({ error: result.error }, result.status as any);
     }
+    
+    return c.json(result.data, result.status as any);
   });
 
   // LIST
   app.post(\`\${base}/list\`, async (c) => {
-    try {
-      const body = listSchema.safeParse(await c.req.json().catch(() => ({})));
-      if (!body.success) {
-        const issues = body.error.flatten();
-        log.debug("LIST ${fileTableName} invalid:", issues);
-        return c.json({ error: "Invalid body", issues }, 400);
-      }
-      const { include, limit = 50, offset = 0 } = body.data;
-
-      const where = ${softDel ? `\`WHERE "${softDel}" IS NULL\`` : `""`};
-      const text = \`SELECT * FROM "${fileTableName}" \${where} LIMIT $1 OFFSET $2\`;
-      log.debug("LIST ${fileTableName} SQL:", text, "params:", [limit, offset]);
-      const { rows } = await deps.pg.query(text, [limit, offset]);
-
-      if (!include) {
-        log.debug("LIST ${fileTableName} rows:", rows.length);
-        return c.json(rows);
-      }
-
-      // Attempt include stitching with explicit error handling
-      log.debug("LIST ${fileTableName} include spec:", include);
+    const body = listSchema.safeParse(await c.req.json().catch(() => ({})));
+    
+    if (!body.success) {
+      const issues = body.error.flatten();
+      return c.json({ error: "Invalid body", issues }, 400);
+    }
+    
+    const result = await coreOps.listRecords(ctx, body.data);
+    
+    if (result.error) {
+      return c.json({ error: result.error }, result.status as any);
+    }
+    
+    // Handle includes if needed
+    if (result.needsIncludes && result.includeSpec) {
       try {
-        const stitched = await loadIncludes("${fileTableName}", rows, include, deps.pg, ${opts.includeDepthLimit});
-        log.debug("LIST ${fileTableName} stitched count:", Array.isArray(stitched) ? stitched.length : "n/a");
+        const stitched = await loadIncludes(
+          "${fileTableName}", 
+          result.data, 
+          result.includeSpec, 
+          deps.pg, 
+          ${opts.includeDepthLimit}
+        );
         return c.json(stitched);
       } catch (e: any) {
-        const strict = process.env.SDK_STRICT_INCLUDE === "1" || process.env.SDK_STRICT_INCLUDE === "true";
-        const msg = e?.message ?? String(e);
-        const stack = e?.stack;
-        log.error("LIST ${fileTableName} include stitch FAILED:", msg, stack);
-
+        const strict = process.env.SDK_STRICT_INCLUDE === "1";
         if (strict) {
-          return c.json({ error: "include-stitch-failed", message: msg, ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+          return c.json({ 
+            error: "include-stitch-failed", 
+            message: e?.message,
+            ...(process.env.SDK_DEBUG === "1" ? { stack: e?.stack } : {})
+          }, 500);
         }
-        // Non-strict fallback: return base rows plus error metadata
-        return c.json({ data: rows, includeError: { message: msg, ...(DEBUG ? { stack: e?.stack } : {}) } }, 200);
+        // Non-strict: return base rows with error metadata
+        return c.json({ 
+          data: result.data, 
+          includeError: { 
+            message: e?.message,
+            ...(process.env.SDK_DEBUG === "1" ? { stack: e?.stack } : {})
+          }
+        }, 200);
       }
-    } catch (e: any) {
-      log.error("LIST ${fileTableName} error:", e?.stack ?? e);
-      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
     }
+    
+    return c.json(result.data, result.status as any);
   });
 
   // UPDATE
   app.patch(\`\${base}/${pkPath}\`, async (c) => {
-    try {
-      ${getPkParams}
-      const body = await c.req.json().catch(() => ({}));
-      log.debug("PATCH ${fileTableName} pk:", pkValues, "patch:", body);
-      const parsed = Update${Type}Schema.safeParse(body);
-      if (!parsed.success) {
-        const issues = parsed.error.flatten();
-        log.debug("PATCH ${fileTableName} invalid:", issues);
-        return c.json({ error: "Invalid body", issues: issues }, 400);
-      }
-
-      ${pkFilter}
-      if (!Object.keys(updateData).length) return c.json({ error: "No updatable fields provided" }, 400);
-
-      const setSql = ${updateSetSql};
-      const text = \`UPDATE "${fileTableName}" SET \${setSql} WHERE ${wherePkSql} RETURNING *\`;
-      const params = ${hasCompositePk ? `[...pkValues, ...Object.values(updateData)]` : `[pkValues[0], ...Object.values(updateData)]`};
-      log.debug("PATCH ${fileTableName} SQL:", text, "params:", params);
-      const { rows } = await deps.pg.query(text, params);
-      if (!rows[0]) return c.json(null, 404);
-      return c.json(rows[0]);
-    } catch (e: any) {
-      log.error("PATCH ${fileTableName} error:", e?.stack ?? e);
-      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    ${getPkParams}
+    const body = await c.req.json().catch(() => ({}));
+    const parsed = Update${Type}Schema.safeParse(body);
+    
+    if (!parsed.success) {
+      const issues = parsed.error.flatten();
+      return c.json({ error: "Invalid body", issues }, 400);
+    }
+    
+    const result = await coreOps.updateRecord(ctx, pkValues, parsed.data);
+    
+    if (result.error) {
+      return c.json({ error: result.error }, result.status as any);
     }
+    
+    return c.json(result.data, result.status as any);
   });
 
-  // DELETE (soft or hard)
+  // DELETE
   app.delete(\`\${base}/${pkPath}\`, async (c) => {
-    try {
-      ${getPkParams}
-      ${softDel ? `
-      const text = \`UPDATE "${fileTableName}" SET "${softDel}" = NOW() WHERE ${wherePkSql} RETURNING *\`;
-      log.debug("DELETE (soft) ${fileTableName} SQL:", text, "pk:", pkValues);
-      const { rows } = await deps.pg.query(text, pkValues);
-      if (!rows[0]) return c.json(null, 404);
-      return c.json(rows[0]);` : `
-      const text = \`DELETE FROM "${fileTableName}" WHERE ${wherePkSql} RETURNING *\`;
-      log.debug("DELETE ${fileTableName} SQL:", text, "pk:", pkValues);
-      const { rows } = await deps.pg.query(text, pkValues);
-      if (!rows[0]) return c.json(null, 404);
-      return c.json(rows[0]);`}
-    } catch (e: any) {
-      log.error("DELETE ${fileTableName} error:", e?.stack ?? e);
-      return c.json({ error: e?.message ?? "Internal error", ...(DEBUG ? { stack: e?.stack } : {}) }, 500);
+    ${getPkParams}
+    const result = await coreOps.deleteRecord(ctx, pkValues);
+    
+    if (result.error) {
+      return c.json({ error: result.error }, result.status as any);
     }
+    
+    return c.json(result.data, result.status as any);
   });
 }
 `;
@@ -1012,7 +986,7 @@ export class ${Type}Client extends BaseClient {
 function emitClientIndex(tables) {
   let out = `/* Generated. Do not edit. */
 `;
-  out += `import { BaseClient, AuthConfig } from "./base-client";
+  out += `import { BaseClient, type AuthConfig } from "./base-client";
 `;
   for (const t of tables) {
     out += `import { ${pascal(t.name)}Client } from "./${t.name}";
@@ -1212,13 +1186,14 @@ export abstract class BaseClient {
 }
 
 // src/emit-include-loader.ts
-function emitIncludeLoader(graph, model, maxDepth) {
+function emitIncludeLoader(graph, model, maxDepth, useJsExtensions) {
   const fkIndex = {};
   for (const t of Object.values(model.tables)) {
     fkIndex[t.name] = t.fks.map((f) => ({ from: f.from, toTable: f.toTable, to: f.to }));
   }
+  const ext = useJsExtensions ? ".js" : "";
   return `/* Generated. Do not edit. */
-import { RELATION_GRAPH } from "./include-builder";
+import { RELATION_GRAPH } from "./include-builder${ext}";
 
 // Minimal types to keep the file self-contained
 type Graph = typeof RELATION_GRAPH;
@@ -1737,12 +1712,13 @@ export async function authMiddleware(c: Context, next: Next) {
 `;
 }
 
-// src/emit-router.ts
-function emitRouter(tables, hasAuth, driver = "pg") {
+// src/emit-router-hono.ts
+function emitHonoRouter(tables, hasAuth, useJsExtensions) {
   const tableNames = tables.map((t) => t.name).sort();
+  const ext = useJsExtensions ? ".js" : "";
   const imports = tableNames.map((name) => {
     const Type = pascal(name);
-    return `import { register${Type}Routes } from "./routes/${name}";`;
+    return `import { register${Type}Routes } from "./routes/${name}${ext}";`;
   }).join(`
 `);
   const registrations = tableNames.map((name) => {
@@ -1752,48 +1728,36 @@ function emitRouter(tables, hasAuth, driver = "pg") {
 `);
   const reExports = tableNames.map((name) => {
     const Type = pascal(name);
-    return `export { register${Type}Routes } from "./routes/${name}";`;
+    return `export { register${Type}Routes } from "./routes/${name}${ext}";`;
   }).join(`
 `);
-  const pgExample = driver === "pg" ? `
- * import { Client } from "pg";
- * import { createRouter } from "./generated/server/router";
- * 
- * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();
- * 
- * // Mount all generated routes under /api
- * const apiRouter = createRouter({ pg });
- * app.route("/api", apiRouter);` : `
- * import { neon } from "@neondatabase/serverless";
- * import { createRouter } from "./generated/server/router";
- * 
- * const app = new Hono();
- * const sql = neon(process.env.DATABASE_URL!);
- * 
- * // Create pg-compatible adapter for Neon
- * const pg = {
- *   async query(text: string, params?: any[]) {
- *     const rows = await sql(text, params);
- *     return { rows };
- *   }
- * };
- * 
- * // Mount all generated routes under /api
- * const apiRouter = createRouter({ pg });
- * app.route("/api", apiRouter);`;
   return `/* Generated. Do not edit. */
 import { Hono } from "hono";
-import { SDK_MANIFEST } from "./sdk-bundle";
+import { SDK_MANIFEST } from "./sdk-bundle${ext}";
 ${imports}
-${hasAuth ? `export { authMiddleware } from "./auth";` : ""}
+${hasAuth ? `export { authMiddleware } from "./auth${ext}";` : ""}
 
 /**
  * Creates a Hono router with all generated routes that can be mounted into your existing app.
  * 
  * @example
- * import { Hono } from "hono";${pgExample}
+ * import { Hono } from "hono";
+ * import { createRouter } from "./generated/server/router";
+ * 
+ * // Using pg driver (Node.js)
+ * import { Client } from "pg";
+ * const pg = new Client({ connectionString: process.env.DATABASE_URL });
+ * await pg.connect();
+ * 
+ * // OR using Neon driver (Edge-compatible)
+ * import { Pool } from "@neondatabase/serverless";
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL! });
+ * const pg = pool; // Pool already has the compatible query method
+ * 
+ * // Mount all generated routes
+ * const app = new Hono();
+ * const apiRouter = createRouter({ pg });
+ * app.route("/api", apiRouter);
  * 
  * // Or mount directly at root
  * const router = createRouter({ pg });
@@ -1838,24 +1802,13 @@ ${registrations}
  * Register all generated routes directly on an existing Hono app.
  * 
  * @example
- * import { Hono } from "hono";${driver === "pg" ? `
- * import { Client } from "pg";
+ * import { Hono } from "hono";
  * import { registerAllRoutes } from "./generated/server/router";
  * 
  * const app = new Hono();
- * const pg = new Client({ connectionString: process.env.DATABASE_URL });
- * await pg.connect();` : `
- * import { neon } from "@neondatabase/serverless";
- * import { registerAllRoutes } from "./generated/server/router";
  * 
- * const app = new Hono();
- * const sql = neon(process.env.DATABASE_URL!);
- * const pg = {
- *   async query(text: string, params?: any[]) {
- *     const rows = await sql(text, params);
- *     return { rows };
- *   }
- * };`}
+ * // Setup database connection (see createRouter example for both pg and Neon options)
+ * const pg = yourDatabaseClient;
  * 
  * // Register all routes at once
  * registerAllRoutes(app, { pg });
@@ -1898,6 +1851,222 @@ export const SDK_MANIFEST = {
 `;
 }
 
+// src/emit-core-operations.ts
+function emitCoreOperations() {
+  return `/**
+ * Core database operations that are framework-agnostic.
+ * These functions handle the actual database logic and can be used by any framework adapter.
+ */
+
+import type { z } from "zod";
+
+export interface DatabaseClient {
+  query: (text: string, params?: any[]) => Promise<{ rows: any[] }>;
+}
+
+export interface OperationContext {
+  pg: DatabaseClient;
+  table: string;
+  pkColumns: string[];
+  softDeleteColumn?: string | null;
+  includeDepthLimit: number;
+}
+
+const DEBUG = process.env.SDK_DEBUG === "1" || process.env.SDK_DEBUG === "true";
+const log = {
+  debug: (...args: any[]) => { if (DEBUG) console.debug("[sdk]", ...args); },
+  error: (...args: any[]) => console.error("[sdk]", ...args),
+};
+
+/**
+ * CREATE operation - Insert a new record
+ */
+export async function createRecord(
+  ctx: OperationContext,
+  data: Record<string, any>
+): Promise<{ data?: any; error?: string; issues?: any; status: number }> {
+  try {
+    const cols = Object.keys(data);
+    const vals = Object.values(data);
+    
+    if (!cols.length) {
+      return { error: "No fields provided", status: 400 };
+    }
+
+    const placeholders = cols.map((_, i) => '$' + (i + 1)).join(", ");
+    const text = \`INSERT INTO "\${ctx.table}" (\${cols.map(c => '"' + c + '"').join(", ")})
+                   VALUES (\${placeholders})
+                   RETURNING *\`;
+    
+    log.debug("SQL:", text, "vals:", vals);
+    const { rows } = await ctx.pg.query(text, vals);
+    
+    return { data: rows[0] ?? null, status: rows[0] ? 201 : 500 };
+  } catch (e: any) {
+    log.error(\`POST \${ctx.table} error:\`, e?.stack ?? e);
+    return { 
+      error: e?.message ?? "Internal error", 
+      ...(DEBUG ? { stack: e?.stack } : {}),
+      status: 500 
+    };
+  }
+}
+
+/**
+ * READ operation - Get a record by primary key
+ */
+export async function getByPk(
+  ctx: OperationContext,
+  pkValues: any[]
+): Promise<{ data?: any; error?: string; status: number }> {
+  try {
+    const hasCompositePk = ctx.pkColumns.length > 1;
+    const wherePkSql = hasCompositePk
+      ? ctx.pkColumns.map((c, i) => \`"\${c}" = $\${i + 1}\`).join(" AND ")
+      : \`"\${ctx.pkColumns[0]}" = $1\`;
+    
+    const text = \`SELECT * FROM "\${ctx.table}" WHERE \${wherePkSql} LIMIT 1\`;
+    log.debug(\`GET \${ctx.table} by PK:\`, pkValues, "SQL:", text);
+    
+    const { rows } = await ctx.pg.query(text, pkValues);
+    
+    if (!rows[0]) {
+      return { data: null, status: 404 };
+    }
+    
+    return { data: rows[0], status: 200 };
+  } catch (e: any) {
+    log.error(\`GET \${ctx.table} error:\`, e?.stack ?? e);
+    return { 
+      error: e?.message ?? "Internal error", 
+      ...(DEBUG ? { stack: e?.stack } : {}),
+      status: 500 
+    };
+  }
+}
+
+/**
+ * LIST operation - Get multiple records with optional filters
+ */
+export async function listRecords(
+  ctx: OperationContext,
+  params: { limit?: number; offset?: number; include?: any }
+): Promise<{ data?: any; error?: string; issues?: any; status: number; needsIncludes?: boolean; includeSpec?: any }> {
+  try {
+    const { limit = 50, offset = 0, include } = params;
+    
+    const where = ctx.softDeleteColumn 
+      ? \`WHERE "\${ctx.softDeleteColumn}" IS NULL\` 
+      : "";
+    
+    const text = \`SELECT * FROM "\${ctx.table}" \${where} LIMIT $1 OFFSET $2\`;
+    log.debug(\`LIST \${ctx.table} SQL:\`, text, "params:", [limit, offset]);
+    
+    const { rows } = await ctx.pg.query(text, [limit, offset]);
+    
+    if (!include) {
+      log.debug(\`LIST \${ctx.table} rows:\`, rows.length);
+      return { data: rows, status: 200 };
+    }
+    
+    // Include logic will be handled by the include-loader
+    // For now, just return the rows with a note that includes need to be applied
+    log.debug(\`LIST \${ctx.table} include spec:\`, include);
+    return { data: rows, needsIncludes: true, includeSpec: include, status: 200 };
+  } catch (e: any) {
+    log.error(\`LIST \${ctx.table} error:\`, e?.stack ?? e);
+    return { 
+      error: e?.message ?? "Internal error", 
+      ...(DEBUG ? { stack: e?.stack } : {}),
+      status: 500 
+    };
+  }
+}
+
+/**
+ * UPDATE operation - Update a record by primary key
+ */
+export async function updateRecord(
+  ctx: OperationContext,
+  pkValues: any[],
+  updateData: Record<string, any>
+): Promise<{ data?: any; error?: string; issues?: any; status: number }> {
+  try {
+    // Filter out PK columns from update data
+    const filteredData = Object.fromEntries(
+      Object.entries(updateData).filter(([k]) => !ctx.pkColumns.includes(k))
+    );
+    
+    if (!Object.keys(filteredData).length) {
+      return { error: "No updatable fields provided", status: 400 };
+    }
+    
+    const hasCompositePk = ctx.pkColumns.length > 1;
+    const wherePkSql = hasCompositePk
+      ? ctx.pkColumns.map((c, i) => \`"\${c}" = $\${i + 1}\`).join(" AND ")
+      : \`"\${ctx.pkColumns[0]}" = $1\`;
+    
+    const setSql = Object.keys(filteredData)
+      .map((k, i) => \`"\${k}" = $\${i + pkValues.length + 1}\`)
+      .join(", ");
+    
+    const text = \`UPDATE "\${ctx.table}" SET \${setSql} WHERE \${wherePkSql} RETURNING *\`;
+    const params = [...pkValues, ...Object.values(filteredData)];
+    
+    log.debug(\`PATCH \${ctx.table} SQL:\`, text, "params:", params);
+    const { rows } = await ctx.pg.query(text, params);
+    
+    if (!rows[0]) {
+      return { data: null, status: 404 };
+    }
+    
+    return { data: rows[0], status: 200 };
+  } catch (e: any) {
+    log.error(\`PATCH \${ctx.table} error:\`, e?.stack ?? e);
+    return { 
+      error: e?.message ?? "Internal error", 
+      ...(DEBUG ? { stack: e?.stack } : {}),
+      status: 500 
+    };
+  }
+}
+
+/**
+ * DELETE operation - Delete or soft-delete a record by primary key
+ */
+export async function deleteRecord(
+  ctx: OperationContext,
+  pkValues: any[]
+): Promise<{ data?: any; error?: string; status: number }> {
+  try {
+    const hasCompositePk = ctx.pkColumns.length > 1;
+    const wherePkSql = hasCompositePk
+      ? ctx.pkColumns.map((c, i) => \`"\${c}" = $\${i + 1}\`).join(" AND ")
+      : \`"\${ctx.pkColumns[0]}" = $1\`;
+    
+    const text = ctx.softDeleteColumn
+      ? \`UPDATE "\${ctx.table}" SET "\${ctx.softDeleteColumn}" = NOW() WHERE \${wherePkSql} RETURNING *\`
+      : \`DELETE FROM "\${ctx.table}" WHERE \${wherePkSql} RETURNING *\`;
+    
+    log.debug(\`DELETE \${ctx.softDeleteColumn ? '(soft)' : ''} \${ctx.table} SQL:\`, text, "pk:", pkValues);
+    const { rows } = await ctx.pg.query(text, pkValues);
+    
+    if (!rows[0]) {
+      return { data: null, status: 404 };
+    }
+    
+    return { data: rows[0], status: 200 };
+  } catch (e: any) {
+    log.error(\`DELETE \${ctx.table} error:\`, e?.stack ?? e);
+    return { 
+      error: e?.message ?? "Internal error", 
+      ...(DEBUG ? { stack: e?.stack } : {}),
+      status: 500 
+    };
+  }
+}`;
+}
+
 // src/types.ts
 function normalizeAuthConfig(input) {
   if (!input)
@@ -1954,6 +2123,7 @@ async function generate(configPath) {
     clientDir = join(originalClientDir, "sdk");
   }
   const normDateType = cfg.dateType === "string" ? "string" : "date";
+  const serverFramework = cfg.serverFramework || "hono";
   console.log("\uD83D\uDCC1 Creating directories...");
   await ensureDirs([
     serverDir,
@@ -1974,12 +2144,16 @@ async function generate(configPath) {
   });
   files.push({
     path: join(serverDir, "include-loader.ts"),
-    content: emitIncludeLoader(graph, model, cfg.includeDepthLimit || 3)
+    content: emitIncludeLoader(graph, model, cfg.includeDepthLimit || 3, cfg.useJsExtensions)
   });
   files.push({ path: join(serverDir, "logger.ts"), content: emitLogger() });
   if (normalizedAuth?.strategy && normalizedAuth.strategy !== "none") {
     files.push({ path: join(serverDir, "auth.ts"), content: emitAuth(normalizedAuth) });
   }
+  files.push({
+    path: join(serverDir, "core", "operations.ts"),
+    content: emitCoreOperations()
+  });
   for (const table of Object.values(model.tables)) {
     const typesSrc = emitTypes(table, { dateType: normDateType, numericMode: "string" });
     files.push({ path: join(serverDir, "types", `${table.name}.ts`), content: typesSrc });
@@ -1988,13 +2162,20 @@ async function generate(configPath) {
       path: join(serverDir, "zod", `${table.name}.ts`),
       content: emitZod(table, { dateType: normDateType, numericMode: "string" })
     });
-    files.push({
-      path: join(serverDir, "routes", `${table.name}.ts`),
-      content: emitRoutes(table, graph, {
+    let routeContent;
+    if (serverFramework === "hono") {
+      routeContent = emitHonoRoutes(table, graph, {
         softDeleteColumn: cfg.softDeleteColumn || null,
         includeDepthLimit: cfg.includeDepthLimit || 3,
-        authStrategy: normalizedAuth?.strategy
-      })
+        authStrategy: normalizedAuth?.strategy,
+        useJsExtensions: cfg.useJsExtensions
+      });
+    } else {
+      throw new Error(`Framework "${serverFramework}" is not yet supported. Currently only "hono" is available.`);
+    }
+    files.push({
+      path: join(serverDir, "routes", `${table.name}.ts`),
+      content: routeContent
     });
     files.push({
       path: join(clientDir, `${table.name}.ts`),
@@ -2005,10 +2186,12 @@ async function generate(configPath) {
     path: join(clientDir, "index.ts"),
     content: emitClientIndex(Object.values(model.tables))
   });
-  files.push({
-    path: join(serverDir, "router.ts"),
-    content: emitRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none", cfg.driver || "pg")
-  });
+  if (serverFramework === "hono") {
+    files.push({
+      path: join(serverDir, "router.ts"),
+      content: emitHonoRouter(Object.values(model.tables), !!normalizedAuth?.strategy && normalizedAuth.strategy !== "none", cfg.useJsExtensions)
+    });
+  }
   const clientFiles = files.filter((f) => {
     return f.path.includes(clientDir);
   });