tina4-nodejs 3.10.91 → 3.10.93

package/packages/frond/src/engine.ts

@@ -357,10 +357,26 @@ function resolveVar(expr: string, context: Record<string, unknown>): unknown {
       return null;
     }
 
+    // Slice syntax: value[1:5], value[:10], value[start:end]
+    const isQuotedPart = (part.startsWith('"') && part.endsWith('"')) ||
+                         (part.startsWith("'") && part.endsWith("'"));
+    if (isBracket && part.includes(":") && !isQuotedPart) {
+      const sliceParts = part.split(":", 2);
+      const sStart = sliceParts[0].trim() ? parseInt(String(evalExpr(sliceParts[0].trim(), context)), 10) : undefined;
+      const sEnd = sliceParts[1].trim() ? parseInt(String(evalExpr(sliceParts[1].trim(), context)), 10) : undefined;
+      if (Array.isArray(value)) {
+        value = (value as unknown[]).slice(sStart ?? 0, sEnd);
+      } else if (typeof value === "string") {
+        value = (value as string).slice(sStart ?? 0, sEnd);
+      } else {
+        return null;
+      }
+      continue;
+    }
+
     let key: string | number;
     // Check if this part came from bracket access and needs variable resolution
-    if ((part.startsWith('"') && part.endsWith('"')) ||
-        (part.startsWith("'") && part.endsWith("'"))) {
+    if (isQuotedPart) {
       // Quoted string literal — strip quotes
       key = part.slice(1, -1);
     } else {
@@ -369,7 +385,7 @@ function resolveVar(expr: string, context: Record<string, unknown>): unknown {
         key = asNum;
       } else if (isBracket) {
         // Only resolve as a variable from context for bracket-derived parts
-        const resolved = context[part];
+        const resolved = evalExpr(part, context);
         key = resolved !== undefined ? String(resolved) : part;
       } else {
         // Dot-derived parts or root — use the part name directly as the key
@@ -397,10 +413,11 @@ function resolveVar(expr: string, context: Record<string, unknown>): unknown {
 function findOutsideQuotes(expr: string, needle: string): number {
   let inQuote: string | null = null;
   let depth = 0;
+  let bracketDepth = 0;
   let i = 0;
   while (i <= expr.length - needle.length) {
     const ch = expr[i];
-    if ((ch === '"' || ch === "'") && depth === 0) {
+    if ((ch === '"' || ch === "'") && depth === 0 && bracketDepth === 0) {
       if (inQuote === null) {
         inQuote = ch;
       } else if (ch === inQuote) {
@@ -412,7 +429,9 @@ function findOutsideQuotes(expr: string, needle: string): number {
     if (inQuote) { i++; continue; }
     if (ch === "(") depth++;
     else if (ch === ")") depth--;
-    if (depth === 0 && expr.slice(i, i + needle.length) === needle) {
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    if (depth === 0 && bracketDepth === 0 && expr.slice(i, i + needle.length) === needle) {
       return i;
     }
     i++;
@@ -425,10 +444,11 @@ function splitOutsideQuotes(expr: string, sep: string): string[] {
   let currentStart = 0;
   let inQuote: string | null = null;
   let depth = 0;
+  let bracketDepth = 0;
   let i = 0;
   while (i <= expr.length - sep.length) {
     const ch = expr[i];
-    if ((ch === '"' || ch === "'") && depth === 0) {
+    if ((ch === '"' || ch === "'") && depth === 0 && bracketDepth === 0) {
       if (inQuote === null) {
         inQuote = ch;
       } else if (ch === inQuote) {
@@ -440,7 +460,9 @@ function splitOutsideQuotes(expr: string, sep: string): string[] {
     if (inQuote) { i++; continue; }
     if (ch === "(") depth++;
     else if (ch === ")") depth--;
-    if (depth === 0 && expr.slice(i, i + sep.length) === sep) {
+    else if (ch === "[") bracketDepth++;
+    else if (ch === "]") bracketDepth--;
+    if (depth === 0 && bracketDepth === 0 && expr.slice(i, i + sep.length) === sep) {
       parts.push(expr.slice(currentStart, i));
       i += sep.length;
       currentStart = i;
@@ -1446,10 +1468,46 @@ export class Frond {
 
   private extractBlocks(source: string): Record<string, string> {
     const blocks: Record<string, string> = {};
-    const pattern = /\{%[-\s]*block\s+(\w+)\s*[-]?%\}([\s\S]*?)\{%[-\s]*endblock\s*[-]?%\}/g;
-    let m: RegExpExecArray | null;
-    while ((m = pattern.exec(source)) !== null) {
-      blocks[m[1]] = m[2];
+    const blockOpen = /\{%[-\s]*block\s+(\w+)\s*[-]?%\}/g;
+    const blockClose = /\{%[-\s]*endblock\s*[-]?%\}/g;
+
+    let pos = 0;
+    while (pos < source.length) {
+      blockOpen.lastIndex = pos;
+      const mOpen = blockOpen.exec(source);
+      if (!mOpen) break;
+
+      const name = mOpen[1];
+      const contentStart = mOpen.index + mOpen[0].length;
+      let depth = 1;
+      let scan = contentStart;
+
+      while (depth > 0 && scan < source.length) {
+        blockOpen.lastIndex = scan;
+        blockClose.lastIndex = scan;
+        const nextOpen = blockOpen.exec(source);
+        const nextClose = blockClose.exec(source);
+
+        if (!nextClose) break; // malformed — no matching endblock
+
+        if (nextOpen && nextOpen.index < nextClose.index) {
+          depth++;
+          scan = nextOpen.index + nextOpen[0].length;
+        } else {
+          depth--;
+          if (depth === 0) {
+            blocks[name] = source.slice(contentStart, nextClose.index);
+            pos = nextClose.index + nextClose[0].length;
+            break;
+          }
+          scan = nextClose.index + nextClose[0].length;
+        }
+      }
+
+      if (depth > 0) {
+        // malformed, skip forward
+        pos = contentStart;
+      }
     }
     return blocks;
   }
@@ -1459,6 +1517,40 @@ export class Frond {
     context: Record<string, unknown>,
     childBlocks: Record<string, string>,
   ): string {
+    // --- Multi-level extends: check if parent itself extends a grandparent ---
+    const extendsMatch = parentSource.trimStart().match(/\{%[-\s]*extends\s+["'](.+?)["']\s*[-]?%\}/);
+    if (extendsMatch) {
+      const grandparentName = extendsMatch[1];
+      const grandparentSource = this.load(grandparentName);
+
+      // Extract block defaults defined in the parent template
+      const parentBlocks = this.extractBlocks(parentSource);
+
+      // Child blocks override parent blocks at the same name
+      const mergedBlocks: Record<string, string> = { ...parentBlocks, ...childBlocks };
+
+      // Resolve nested blocks: if a block value contains {% block inner %} tags,
+      // replace them with mergedBlocks values too
+      const nestedBlockRe = /\{%[-\s]*block\s+(\w+)\s*[-]?%\}([\s\S]*?)\{%[-\s]*endblock\s*[-]?%\}/g;
+      let changed = true;
+      while (changed) {
+        changed = false;
+        for (const name of Object.keys(mergedBlocks)) {
+          const resolved = mergedBlocks[name].replace(nestedBlockRe, (_m, innerName: string, innerDefault: string) => {
+            return mergedBlocks[innerName] ?? innerDefault;
+          });
+          if (resolved !== mergedBlocks[name]) {
+            mergedBlocks[name] = resolved;
+            changed = true;
+          }
+        }
+      }
+
+      // Recurse up the chain (handles 3+, 4+, ... levels)
+      return this.renderWithBlocks(grandparentSource, context, mergedBlocks);
+    }
+
+    // --- Leaf parent (no extends) — resolve blocks and render ---
     const pattern = /\{%[-\s]*block\s+(\w+)\s*[-]?%\}([\s\S]*?)\{%[-\s]*endblock\s*[-]?%\}/g;
     const engine = this;
 

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";