tina4-nodejs 3.10.91 → 3.10.92

package/packages/orm/src/autoCrud.ts

@@ -4,6 +4,70 @@ import { getAdapter } from "./database.js";
 import { buildQuery, parseQueryString } from "./query.js";
 import { validate } from "./validation.js";
 
+/**
+ * Auto-CRUD — discovers ORM models and auto-generates REST endpoints.
+ *
+ * Generated endpoints per model:
+ *   GET    /api/{table}        — list with pagination, filtering, sorting
+ *   GET    /api/{table}/{id}   — get single record
+ *   POST   /api/{table}        — create record
+ *   PUT    /api/{table}/{id}   — update record
+ *   DELETE /api/{table}/{id}   — delete record
+ */
+export class AutoCrud {
+  private static registered: Map<string, DiscoveredModel> = new Map();
+
+  /**
+   * Register a model for auto-CRUD.
+   */
+  static register(model: DiscoveredModel, prefix: string = "/api"): void {
+    const tableName = model.definition.tableName;
+    if (!tableName) {
+      throw new Error(`AutoCrud: model has no tableName set.`);
+    }
+    AutoCrud.registered.set(tableName, model);
+  }
+
+  /**
+   * Discover models from the provided array and register them.
+   * (In Node.js, models are discovered by the server and passed in.)
+   */
+  static discover(discoveredModels: DiscoveredModel[], prefix: string = "/api"): string[] {
+    const names: string[] = [];
+    for (const model of discoveredModels) {
+      AutoCrud.register(model, prefix);
+      names.push(model.definition.tableName);
+    }
+    return names;
+  }
+
+  /**
+   * Return all registered models.
+   */
+  static models(): Map<string, DiscoveredModel> {
+    return new Map(AutoCrud.registered);
+  }
+
+  /**
+   * Clear all registered models (useful for testing).
+   */
+  static clear(): void {
+    AutoCrud.registered.clear();
+  }
+
+  /**
+   * Generate route definitions for all registered models.
+   */
+  static generateRoutes(): RouteDefinition[] {
+    const models = Array.from(AutoCrud.registered.values());
+    return generateCrudRoutes(models);
+  }
+}
+
+/**
+ * Generate CRUD route definitions for the given models.
+ * (Standalone function for backward compatibility.)
+ */
 export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[] {
   const routes: RouteDefinition[] = [];
 
@@ -38,33 +102,28 @@ export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[]
       },
       handler: async (req: Tina4Request, res: Tina4Response) => {
         const adapter = getAdapter();
-        const options = parseQueryString(req.query);
-        const { sql, countSql, params } = buildQuery(tableName, options, extraConditions);
 
-        const countParams = params.slice(0, -2); // Remove LIMIT and OFFSET
-        const items = adapter.query(sql, params);
-        const [{ total }] = adapter.query<{ total: number }>(countSql, countParams);
+        // Parse query params for filtering / sorting / pagination
+        const qp = parseQueryString(req.query ?? {});
+        const { sql, countSql, params } = buildQuery(tableName, qp, extraConditions);
+
+        // params includes limit and offset at the end; countSql doesn't need them
+        const countParams = params.slice(0, -2);
+        const rows = adapter.query(sql, params);
 
-        const limit = options.limit ?? 100;
-        const page = options.page ?? 1;
-        const offset = (page - 1) * limit;
-        const totalPages = Math.ceil(total / limit);
+        const countRow = adapter.query(countSql, countParams);
+        const total = Number(countRow[0]?.total ?? 0);
+        const limit = qp.limit ?? 100;
+        const page = qp.page ?? 1;
 
         res.json({
-          // Primary keys
-          records: items,
-          data: items,
-          count: total,
-          total,
-          limit,
-          offset,
-          page,
-          per_page: limit,
-          perPage: limit,
-          totalPages,
-          total_pages: totalPages,
-          // Legacy nested meta (kept for any clients that use it)
-          meta: { total, page, limit, totalPages },
+          data: rows,
+          meta: {
+            total,
+            page,
+            limit,
+            totalPages: Math.ceil(total / limit),
+          },
         });
       },
     });
@@ -79,16 +138,19 @@ export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[]
       },
       handler: async (req: Tina4Request, res: Tina4Response) => {
         const adapter = getAdapter();
+
         const conditions = [`"${pkColumn}" = ?`, ...extraConditions];
-        const items = adapter.query(
+        const rows = adapter.query(
           `SELECT * FROM "${tableName}" WHERE ${conditions.join(" AND ")}`,
           [req.params.id],
         );
-        if (items.length === 0) {
+
+        if (rows.length === 0) {
           res.status(404).json({ error: "Not Found", statusCode: 404 });
           return;
         }
-        res.json({ data: items[0] });
+
+        res.json({ data: rows[0] });
       },
     });
 
@@ -101,47 +163,39 @@ export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[]
         tags: [tableName],
       },
       handler: async (req: Tina4Request, res: Tina4Response) => {
-        const body = req.body as Record<string, unknown> | undefined;
-        if (!body || typeof body !== "object") {
-          res.status(400).json({ error: "Request body is required", statusCode: 400 });
-          return;
-        }
+        const adapter = getAdapter();
+        const body = req.body as Record<string, unknown>;
 
-        const errors = validate(body, fields, false);
+        // Validate against field definitions
+        const errors = validate(body, fields);
         if (errors.length > 0) {
-          res.status(422).json({ error: "Validation failed", statusCode: 422, errors });
+          res.status(422).json({ error: "Validation failed", errors });
           return;
         }
 
-        const adapter = getAdapter();
-
-        // Filter to known fields, exclude auto-increment PKs
-        const insertFields = Object.entries(body).filter(([key]) => {
-          const def = fields[key];
-          return def && !(def.primaryKey && def.autoIncrement);
-        });
-
-        // Add is_deleted = 0 for soft delete models
-        if (softDelete) {
-          insertFields.push(["is_deleted", 0]);
+        // Map JS property names to DB column names
+        const dbBody: Record<string, unknown> = {};
+        for (const [key, value] of Object.entries(body)) {
+          dbBody[getDbCol(key)] = value;
         }
 
-        const columns = insertFields.map(([k]) => `"${getDbCol(k)}"`).join(", ");
-        const placeholders = insertFields.map(() => "?").join(", ");
-        const values = insertFields.map(([, v]) => v);
+        const columns = Object.keys(dbBody);
+        const values = Object.values(dbBody);
+        const placeholders = columns.map(() => "?").join(", ");
 
-        const result = adapter.execute(
-          `INSERT INTO "${tableName}" (${columns}) VALUES (${placeholders})`,
+        adapter.execute(
+          `INSERT INTO "${tableName}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
           values,
-        ) as { lastInsertRowid?: number };
+        );
 
-        const id = result.lastInsertRowid;
+        // Fetch the created record to include auto-generated fields (e.g. id)
+        const lastId = adapter.lastInsertId();
         const created = adapter.query(
           `SELECT * FROM "${tableName}" WHERE "${pkColumn}" = ?`,
-          [id],
+          [lastId],
         );
 
-        res.status(201).json({ data: created[0] });
+        res.status(201).json({ data: created[0] ?? { ...body, [pkField]: lastId } });
       },
     });
 
@@ -154,21 +208,9 @@ export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[]
         tags: [tableName],
       },
       handler: async (req: Tina4Request, res: Tina4Response) => {
-        const body = req.body as Record<string, unknown> | undefined;
-        if (!body || typeof body !== "object") {
-          res.status(400).json({ error: "Request body is required", statusCode: 400 });
-          return;
-        }
-
-        const errors = validate(body, fields, true);
-        if (errors.length > 0) {
-          res.status(422).json({ error: "Validation failed", statusCode: 422, errors });
-          return;
-        }
-
         const adapter = getAdapter();
+        const body = req.body as Record<string, unknown>;
 
-        // Check exists (respect soft delete)
         const conditions = [`"${pkColumn}" = ?`, ...extraConditions];
         const existing = adapter.query(
           `SELECT * FROM "${tableName}" WHERE ${conditions.join(" AND ")}`,
@@ -179,18 +221,19 @@ export function generateCrudRoutes(models: DiscoveredModel[]): RouteDefinition[]
           return;
         }
 
-        // Filter to known fields
-        const updateFields = Object.entries(body).filter(([key]) => fields[key] && !fields[key].primaryKey);
-        if (updateFields.length === 0) {
-          res.json({ data: existing[0] });
-          return;
+        // Map JS property names to DB column names
+        const dbBody: Record<string, unknown> = {};
+        for (const [key, value] of Object.entries(body)) {
+          dbBody[getDbCol(key)] = value;
         }
 
-        const setClause = updateFields.map(([k]) => `"${getDbCol(k)}" = ?`).join(", ");
-        const values = [...updateFields.map(([, v]) => v), req.params.id];
+        const setClauses = Object.keys(dbBody)
+          .map((col) => `"${col}" = ?`)
+          .join(", ");
+        const values = [...Object.values(dbBody), req.params.id];
 
         adapter.execute(
-          `UPDATE "${tableName}" SET ${setClause} WHERE "${pkColumn}" = ?`,
+          `UPDATE "${tableName}" SET ${setClauses} WHERE "${pkColumn}" = ?`,
           values,
         );
 

package/packages/orm/src/baseModel.ts

@@ -201,7 +201,7 @@ export class BaseModel {
    * @returns A QueryBuilder instance bound to this model's table and database.
    */
   static query(): QueryBuilder {
-    return QueryBuilder.from(this.tableName, this.getDb());
+    return QueryBuilder.fromTable(this.tableName, this.getDb());
   }
 
   /**

package/packages/orm/src/databaseResult.ts

@@ -122,6 +122,11 @@ export class DatabaseResult implements Iterable<Record<string, unknown>> {
     return this.records[Symbol.iterator]();
   }
 
+  /** Total count — cross-framework parity with Python/Ruby. */
+  size(): number {
+    return this.count;
+  }
+
   /** Number of records in this page. */
   get length(): number {
     return this.records.length;

package/packages/orm/src/index.ts

@@ -35,7 +35,7 @@ export {
   Migration,
 } from "./migration.js";
 export type { MigrationResult, MigrationStatus } from "./migration.js";
-export { generateCrudRoutes } from "./autoCrud.js";
+export { AutoCrud, generateCrudRoutes } from "./autoCrud.js";
 export { buildQuery, parseQueryString } from "./query.js";
 export { validate } from "./validation.js";
 export type { ValidationError } from "./validation.js";

package/packages/orm/src/migration.ts

@@ -706,8 +706,11 @@ export async function status(
  */
 export async function createMigration(
   description: string,
-  options?: { migrationsDir?: string },
-): Promise<{ upPath: string; downPath: string }> {
+  options?: { migrationsDir?: string; kind?: "sql" | "class" },
+): Promise<string | { upPath: string; downPath: string }> {
+  if (options?.kind === "class") {
+    return createClassMigration(description, options);
+  }
   const dir = resolve(options?.migrationsDir ?? "migrations");
 
   // Ensure directory exists

package/packages/orm/src/queryBuilder.ts

@@ -3,7 +3,7 @@
  *
  * Usage:
  *   // Standalone
- *   const result = QueryBuilder.from("users", db)
+ *   const result = QueryBuilder.fromTable("users", db)
  *     .select("id", "name")
  *     .where("active = ?", [1])
  *     .orderBy("name ASC")
@@ -49,7 +49,7 @@ export class QueryBuilder {
    * @param db - Optional database adapter.
    * @returns A new QueryBuilder instance.
    */
-  static from(tableName: string, db?: DatabaseAdapter): QueryBuilder {
+  static fromTable(tableName: string, db?: DatabaseAdapter): QueryBuilder {
     return new QueryBuilder(tableName, db);
   }
 

package/packages/swagger/src/generator.ts

@@ -8,9 +8,9 @@ interface OpenAPISpec {
   components?: { schemas?: Record<string, unknown> };
 }
 
-export function generateOpenAPISpec(
+export function generate(
   routes: RouteDefinition[],
-  models: ModelDefinition[]
+  models: ModelDefinition[] = []
 ): OpenAPISpec {
   const spec: OpenAPISpec = {
     openapi: "3.0.3",

package/packages/swagger/src/index.ts

@@ -1,2 +1,2 @@
-export { generateOpenAPISpec } from "./generator.js";
+export { generate } from "./generator.js";
 export { createSwaggerRoutes } from "./ui.js";