fastify-auto-sqlapi 0.0.4 → 0.0.5

package/AGENTS_BACKEND.md

@@ -21,15 +21,16 @@ npm install @fastify/swagger @fastify/swagger-ui
 Create `sqlapi.config.ts` (or `.js`) in the project root. This config is used **only by the CLI** (`sqlapi-generate-schema` / `sqlapi-generate-tables`), NOT at runtime by the Fastify plugin.
 
 ```typescript
-// sqlapi.config.ts — interface: { outputDir: string; schema?: string; dialect?: DialectName }
+// sqlapi.config.ts — interface: { outputDir: string; schema?: string; dialect?: DialectName; envFile?: string }
 export default {
   outputDir: './src/db',       // base directory for generated files (default: './src/db')
   schema: 'public',            // DB schema to introspect (default: 'public', PostgreSQL only)
   dialect: 'postgres',         // 'postgres' | 'mysql' | 'mariadb' (default: 'postgres')
+  // envFile: '../../.env',    // path to .env file, relative to cwd (default: '.env')
 };
 ```
 
-That's it — only these three fields exist. **No connection string, no migration path.** If the file is missing, defaults are used. The `dialect` can also be passed via CLI flag `--dialect mysql`.
+That's it — only these four fields exist. **No connection string, no migration path.** If the file is missing, defaults are used. The `dialect` can also be passed via CLI flag `--dialect mysql`. The `envFile` is useful in monorepo setups where the `.env` lives at the repo root.
 
 ### 3. Configure database connection (env vars)
 
@@ -282,17 +283,17 @@ export const TableCustomer = defineTable({
     return []; // ValidationError[]
   },
 
-  // HOOKS — side effects (runs after validation)
+  // HOOKS — side effects (runs after validation). All receive camelCase (schema field names).
   beforeInsert: async (db, req, record) => {
-    // Mutate record before INSERT. record is snake_case.
-    record.created_by = req.user.id;
+    // Mutate record before INSERT. Use camelCase (schema) field names — conversion is automatic.
+    record.createdBy = req.user.id;
   },
   afterInsert: async (db, req, record, secondaryRecords) => {
-    // Called after INSERT + secondaries. record is camelCase.
+    // Called after INSERT + secondaries. record is camelCase (input merged with generated PK).
   },
   beforeUpdate: async (db, req, fields) => {
-    // Mutate fields before UPDATE. fields is snake_case.
-    fields.updated_by = req.user.id;
+    // Mutate fields before UPDATE. camelCase. PK is present for reference but excluded from UPDATE SET.
+    fields.updatedBy = req.user.id;
   },
 
   // AUTH — per-table request hooks
@@ -430,6 +431,8 @@ const sqlApi = createSqlApi(db, dbTables, { dialect: 'mysql' });
 
 ```typescript
 // Search — full filter, join, pagination, aggregation support
+// orderBy supports dot notation for joinGroup aggregations: "session.sum.duration DESC"
+// (requires the joinGroup to be declared in the same request, see AGENTS_FRONTEND.md)
 sqlApi.search(tableName, {
   filters?, joinFilters?, joins?, joinGroups?,
   orderBy?, paginator?, computeMin?, computeMax?, computeSum?, computeAvg?,
@@ -590,14 +593,14 @@ Tables without `tenantScope` are unaffected — no filtering regardless of `getT
 
 ## Key Conventions
 
-- **camelCase in API, snake_case in DB**: all request/response fields are camelCase. The plugin converts automatically via `col()`.
+- **camelCase in API, any case in DB**: all request/response fields are camelCase. The plugin converts via `col()` and `colMap`. For snake_case DB columns (default), conversion is automatic. For camelCase DB columns (e.g. betterauth), the CLI generates a `colMap` that preserves the original column names — no conversion needed. Manual schemas without `colMap` fall back to `toUnderscore()`.
 - **All fields Optional in response**: `RETURNING *` may return any subset. Response schemas use `Type.Partial`.
 - **`excludeFromCreation`**: **IMPORTANT** — auto-increment PKs (e.g. `id` serial/auto_increment) MUST be listed here, otherwise INSERT will try to send them and fail. The CLI auto-detects this and adds it by default. Also useful for `createdAt`/`updatedAt` columns managed by DB defaults or hooks.
 - **`upsertMap`**: when present for a schema, INSERT becomes upsert. PostgreSQL: `ON CONFLICT (...) DO UPDATE`. MySQL/MariaDB: `ON DUPLICATE KEY UPDATE`. Applies to both main and secondary tables.
 - **`schemaOverrides`**: override auto-generated schema fields with stricter TypeBox types (e.g. `{ email: Type.String({ format: 'email' }) }`). Overrides are merged into the body schema for insert, update, and bulk-upsert. The original Schema file is never modified. In updates, overridden fields are still wrapped in Optional (validates only when present). Overrides appear in Swagger.
 - **Validation receives camelCase**: `validate` receives the original camelCase record (as sent by the client) and secondaries. Field names match the schema definition, with full TypeScript inference (`main.startDate`, not `main.start_date`). It returns `ValidationError[]` — tuples of `[field, code]` or `[field, code, message]`. If any errors are returned, the request is rejected with 400 before hooks or SQL execute.
 - **`validateBulk` replaces `validate` in bulk**: when `validateBulk` is defined, it is called once with all items and per-item `validate` is skipped. This allows optimized batch queries instead of N individual checks. When only `validate` is defined, it runs per-item as fallback.
-- **Hooks receive snake_case, validate receives camelCase**: `validate(db, req, main, secondaries)` gets camelCase (pre-conversion). `beforeInsert(db, req, record)` and `beforeUpdate(db, req, fields)` get snake_case (post-conversion). `afterInsert` receives camelCase (post-DB).
+- **All hooks and validators receive camelCase records**: `validate`, `beforeInsert`, `beforeUpdate`, and `afterInsert` all get records keyed by schema field names (camelCase). Mutations propagate to the SQL (plugin converts to DB column format via `colMap` after the hook). The engine internally uses `snakecaseRecord(..., schema)` after user mutations to map field names to actual DB columns.
 - **Filters validation**: TypeBox schemas use `additionalProperties: false`. By default Fastify strips unknown fields silently. For 400 errors on unknown filters: `Fastify({ ajv: { customOptions: { removeAdditional: false } } })`.
 - **Tenant filtering**: when `tenantScope` is set on a table and `getTenantId` is provided in plugin options, all CRUD operations are automatically scoped to the tenant. `getTenantId` returning `null`/`undefined` = admin (no filter). Returning an array = multi-tenant user (IN clause).
 
@@ -699,12 +702,13 @@ const TableCustomer = defineTable({
   primary: 'id',
   ...exportTableInfo(SchemaCustomer),
   beforeInsert: async (db, req, record) => {
-    record.created_by = req.user.id;
-    record.created_at = db.expression('NOW()');
+    // camelCase — schema field names. The plugin converts to the actual DB column names.
+    record.createdBy = req.user.id;
+    record.createdAt = db.expression('NOW()');
   },
   beforeUpdate: async (db, req, fields) => {
-    fields.updated_by = req.user.id;
-    fields.updated_at = db.expression('NOW()');
+    fields.updatedBy = req.user.id;
+    fields.updatedAt = db.expression('NOW()');
   },
 });
 ```

package/AGENTS_FRONTEND.md

@@ -107,6 +107,40 @@ Also available: `isNotGreater`, `isNotGreaterOrEqual`, `isNotLess`, `isNotLessOr
 - **Field validation** — field names are validated against the table schema (400 if unknown)
 - **Method validation** — only whitelisted methods are allowed (`raw`, `append` etc. are blocked)
 
+#### Conditions on joinGroup aggregations (HAVING-style)
+
+You can filter main rows based on the value of a joinGroup aggregation using the same dot notation as `orderBy`: `<joinTable>.<fn>.<field>`.
+
+Example: "users with at least 4 sessions":
+
+```json
+{
+  "conditions": [
+    { "field": "session.count.id", "method": "isGreaterOrEqual", "params": [4] }
+  ],
+  "joinGroups": {
+    "session": { "aggregations": { "count": ["id"] } }
+  }
+}
+```
+
+Generated SQL:
+```sql
+SELECT * FROM "user"
+WHERE COALESCE((
+  SELECT COUNT("session"."id")
+  FROM "session"
+  WHERE "session"."user_id" = "user"."id"
+), 0) >= $1
+```
+
+**Rules:**
+- Same declaration requirement as orderBy: the joinGroup must be declared in `joinGroups.<table>.aggregations.<fn>` with the referenced field.
+- The joinGroup's own `filters` are applied inside the correlated subquery (consistent with the breakdown). Example: filter customers whose SUM of *completed* orders > 1000 by declaring `joinGroups.order.filters: { status: 'completed' }`.
+- All ConditionBuilder methods work: `isEqual`, `isGreater`, `isLess`, `isBetween`, `isIn`, `isNull`, `isNotNull`, etc.
+- Can be combined with plain-field conditions and with aggregation `orderBy` in the same request.
+- Respects `aggregations.by` rules: allowed when `by` equals the correlation FK, otherwise 400.
+
 ### Join Filters (filter main by related table)
 
 `joinFilters` restrict **main table results** based on conditions on a related table. Only tables listed in `allowedReadJoins` are available. Uses `EXISTS` subquery — no duplicate rows, works correctly with pagination.
@@ -151,6 +185,8 @@ The join executes as a separate query: `SELECT ... FROM {joinTable} WHERE {fk} I
         "sum": ["total"],
         "min": ["total"],
         "max": ["total"],
+        "avg": ["total"],
+        "count": ["id"],
         "distinctCount": ["status"]
       },
       "filters": { "status": "active" }
@@ -160,7 +196,8 @@ The join executes as a separate query: `SELECT ... FROM {joinTable} WHERE {fk} I
 ```
 
 - `by` — GROUP BY field
-- `sum`, `min`, `max` — aggregate functions on specified columns
+- `sum`, `min`, `max`, `avg` — aggregate functions on specified columns
+- `count` — COUNT(col)
 - `distinctCount` — COUNT(DISTINCT col)
 - `filters` — optional, narrow rows before aggregation
 
@@ -176,6 +213,46 @@ Use the `orderBy` query parameter:
 
 If not specified, the table's `defaultOrder` is used.
 
+#### Ordering by joinGroup aggregations
+
+You can order the main results by an aggregation computed on a joined table using dot notation: `<joinTable>.<fn>.<field>`.
+
+Supported functions: `sum`, `min`, `max`, `avg`, `count`, `distinctCount`.
+
+Example: get users ordered by total session duration DESC.
+
+```
+POST /auto/search/user?orderBy=session.sum.duration%20DESC
+```
+```json
+{
+  "joinGroups": {
+    "session": {
+      "aggregations": { "sum": ["duration"] }
+    }
+  }
+}
+```
+
+Generated SQL (simplified):
+```sql
+SELECT * FROM "user"
+ORDER BY (
+  SELECT SUM("session"."duration")
+  FROM "session"
+  WHERE "session"."user_id" = "user"."id"
+) DESC
+```
+
+**Rules:**
+- The joinGroup **must be declared in the request body** (`joinGroups.<table>.aggregations.<fn>` must include the field). The engine refuses undeclared references with 400.
+- If the joinGroup declares `aggregations.filters`, those filters are applied inside the correlated subquery — consistent with the breakdown.
+- **`aggregations.by`**: allowed **only** when `by` is the same field used for the join correlation (e.g. `by: "userId"` when joining user→session via userId). In that case each main row maps to exactly one group, so the ordering is well-defined *and* the response contains the per-row breakdown you can render next to each row. Using `by` on any other column is rejected with 400 (the result would be bucketed per group, not per row).
+- **Not allowed** when the main table has `distinctResults: true`. 400 error.
+- Can be combined with plain field ordering: `?orderBy=session.sum.duration DESC, name ASC`.
+- The joinGroup breakdown is still returned in the response (`joinGroups.session.sum.duration` etc.) as before — you get both ordered main results and the aggregated summary.
+- **No-data rows**: rows with no matching joined records are coalesced to `0` via `COALESCE(..., 0)`. Practically: on DESC they appear last, on ASC they appear first. This is universal across PostgreSQL, MySQL, and MariaDB.
+
 ### Pagination
 
 Add `page` or `itemsPerPage` to the query string to enable pagination:

package/README.md

@@ -1,8 +1,8 @@
 # fastify-auto-sqlapi
 
-Automatic CRUD API generation from PostgreSQL tables for [Fastify](https://fastify.dev/). No ORM, no magic — just raw SQL via `pg`, with TypeBox validation and Swagger docs out of the box.
+Automatic CRUD API generation from PostgreSQL, MySQL, and MariaDB tables for [Fastify](https://fastify.dev/). No ORM, no magic — just raw SQL, with TypeBox validation and Swagger docs out of the box.
 
-Point it at your database, and get a full REST API with search, pagination, joins, bulk operations, multi-tenant isolation, and hooks.
+Point it at your database, and get a full REST API with search, advanced conditions, pagination, joins, aggregations, bulk operations, multi-tenant isolation, validation, and hooks.
 
 ## Features
 
@@ -176,10 +176,10 @@ const TableCustomer = defineTable({
     return [];
   },
 
-  // Hooks (runs after validation)
-  beforeInsert: async (db, req, record) => { /* record is snake_case */ },
-  beforeUpdate: async (db, req, fields) => { /* fields is snake_case */ },
-  afterInsert: async (db, req, record, secondaryRecords) => { /* record is camelCase */ },
+  // Hooks (runs after validation) — all receive camelCase records (schema field names)
+  beforeInsert: async (db, req, record) => { /* camelCase; mutations propagate to INSERT */ },
+  beforeUpdate: async (db, req, fields) => { /* camelCase; PK included for reference, excluded from UPDATE SET */ },
+  afterInsert: async (db, req, record, secondaryRecords) => { /* camelCase; input merged with generated PK */ },
 
   // Auth (per-table)
   onRequests: [
@@ -219,37 +219,80 @@ const TableCustomer = defineTable({
 ```typescript
 await app.register(fastifyAutoSqlApi, {
   DbTables: dbTables,           // Required — your table definitions
+  dialect: 'postgres',          // Optional — 'postgres' | 'mysql' | 'mariadb' (default: 'postgres')
   prefix: '/api',               // Optional — URL prefix for all routes
   swagger: true,                // Optional — enable Swagger UI (or pass SwaggerOptions)
   onRequests: [authMiddleware],  // Optional — global hooks applied to every route
   getTenantId: (req) => id,     // Optional — multi-tenant function
+  debug: true,                  // Optional — log all SQL queries and params
 });
 ```
 
 | Option | Type | Required | Description |
 |--------|------|----------|-------------|
 | `DbTables` | `Record<string, ITable>` | Yes | Table configurations |
+| `dialect` | `'postgres' \| 'mysql' \| 'mariadb'` | No | DB dialect (default: `'postgres'`) |
 | `prefix` | `string` | No | URL prefix (e.g. `/api`) |
 | `swagger` | `boolean \| SwaggerOptions` | No | Enable Swagger UI |
 | `onRequests` | `Function[]` | No | Global auth/middleware hooks |
 | `getTenantId` | `(req) => id \| null` | No | Tenant resolver for multi-tenant |
+| `debug` | `boolean` | No | Log all SQL queries to console |
+
+For MySQL/MariaDB, register `mysql2/promise` pool instead of `@fastify/postgres` and pass `dialect: 'mysql'` or `'mariadb'`.
 
 ## API Reference
 
 ### POST /search/{table}
 
-Search with filters, pagination, ordering, joins, and aggregations.
+Search with filters, advanced conditions, pagination, ordering, joins, and aggregations.
 
 **Request body** (all fields optional):
 
 ```json
 {
   "filters": { "name": "Mario" },
-  "joins": { "order": {} },
-  "paginator": { "page": 1, "itemsPerPage": 20 }
+  "conditions": [
+    { "field": "total", "method": "isGreater", "params": [100] },
+    { "field": "createdAt", "method": "isBetween", "params": ["2024-01-01", "2024-12-31"] }
+  ],
+  "joinFilters": {
+    "order": {
+      "filters": { "status": "completed" },
+      "conditions": [{ "field": "total", "method": "isGreater", "params": [50] }]
+    }
+  },
+  "joins": {
+    "order": {
+      "filters": { "status": "completed" },
+      "conditions": [{ "field": "total", "method": "isGreater", "params": [50] }]
+    }
+  },
+  "joinGroups": {
+    "order": {
+      "aggregations": {
+        "by": "status",
+        "sum": ["total"],
+        "min": ["total"],
+        "max": ["total"],
+        "avg": ["total"],
+        "count": ["id"],
+        "distinctCount": ["status"]
+      },
+      "filters": { "status": "completed" },
+      "conditions": [{ "field": "total", "method": "isGreater", "params": [0] }]
+    }
+  }
 }
 ```
 
+- **`filters`** — equality-based, flat key/value. Supports schema fields + `extraFilters`.
+- **`conditions`** — array of `{ field, method, params }`. Methods: `isEqual`, `isNotEqual`, `isGreater`, `isGreaterOrEqual`, `isLess`, `isLessOrEqual`, `isLike`, `isILike`, `isIn`, `isNotIn`, `isBetween`, `isNotBetween`, `isNull`, `isNotNull`.
+- **`joinFilters`** — EXISTS-based filtering: "main rows where at least one related row matches". Accepts `{ filters, conditions }` (both optional). Only tables in `allowedReadJoins`.
+- **`joins`** — fetch related records (virtual join via separate query). Accepts `{ filters, conditions }`.
+- **`joinGroups`** — aggregations on related tables. Supports `sum`, `min`, `max`, `avg`, `count`, `distinctCount`, and optional `by` for GROUP BY. Accepts `{ filters, conditions }` inside the subquery.
+
+**Dot-notation in `conditions` and `orderBy`** — use `<joinTable>.<fn>.<field>` to filter/order the main rows by an aggregation value (HAVING-style). Example: `orderBy=order.sum.total DESC` or `conditions: [{ field: 'order.count.id', method: 'isGreaterOrEqual', params: [4] }]`. The joinGroup must be declared in the body.
+
 **Querystring** (optional): `orderBy`, `page`, `itemsPerPage`, `computeMin`, `computeMax`, `computeSum`, `computeAvg`
 
 **Response:**
@@ -259,11 +302,23 @@ Search with filters, pagination, ordering, joins, and aggregations.
   "table": "customer",
   "main": [{ "id": 1, "name": "Mario", "email": "m@test.it" }],
   "joins": { "order": [{ "id": 10, "customerId": 1, "total": 50 }] },
-  "pagination": { "total": 25, "pages": 3, "paginator": { "page": 1, "itemsPerPage": 20 } }
+  "joinGroups": {
+    "order": {
+      "sum": { "total": 300 },
+      "count": { "id": 2 },
+      "rows": [{ "by": "completed", "sum_total": 300, "count_id": 2 }]
+    }
+  },
+  "pagination": {
+    "total": 25,
+    "pages": 3,
+    "computed": { "min": { "id": 1 }, "max": { "id": 100 } },
+    "paginator": { "page": 1, "itemsPerPage": 20 }
+  }
 }
 ```
 
-`joins`, `joinGroups`, and `pagination` only appear when requested. A simple `{}` body returns `{ table, main }`.
+`joins`, `joinGroups`, and `pagination` only appear when requested. A simple `{}` body returns `{ table, main }`. `pagination.computed` appears only if `computeMin`/`computeMax`/`computeSum`/`computeAvg` are used.
 
 ### GET /rest/{table}/:id
 
@@ -312,6 +367,24 @@ Returns the deleted record or 404.
 
 **Body:** Array of objects with the PK field, e.g. `[{ "id": 1 }, { "id": 2 }]`. Executes as a single `DELETE WHERE pk IN (...)`.
 
+### Validation errors (400)
+
+Both schema-level (TypeBox/Ajv) and custom (`validate` / `validateBulk`) errors use the same response shape:
+
+```json
+{
+  "statusCode": 400,
+  "error": "Bad Request",
+  "message": "Validation failed",
+  "fields": [
+    { "path": "main.email", "code": "format", "message": "must match format \"email\"" },
+    { "path": "name", "code": "required", "message": "is required" }
+  ]
+}
+```
+
+Custom validators return tuples `[field, code]` or `[field, code, message]` — `message` defaults to `code` if omitted. `validateBulk` replaces per-item `validate` in bulk-upsert requests.
+
 ## Multi-Tenant
 
 Automatic row-level isolation on all CRUD operations. Configure once, no code in handlers.
@@ -405,9 +478,9 @@ await app.register(async (instance) => {
 
 ## Conventions
 
-- **camelCase in API, snake_case in DB** — the plugin converts automatically
-- **Joins are virtual** — they execute separate `SELECT ... WHERE fk IN (...)` queries, not SQL JOINs
-- **Hooks receive snake_case** — `beforeInsert` and `beforeUpdate` get snake_case records; `afterInsert` gets camelCase
+- **camelCase everywhere in the API** — requests, responses, `validate`, and all hooks (`beforeInsert`, `beforeUpdate`, `afterInsert`) use schema field names
+- **Conversion to DB column format is automatic** via `colMap` — supports both snake_case and camelCase DB columns (e.g. betterauth-style)
+- **Joins are virtual** — separate `SELECT ... WHERE fk IN (...)` queries, not SQL JOINs
 - **All response fields are Optional** — response schemas use `Type.Partial` since `RETURNING *` may return any subset
 
 ## Re-exports
@@ -417,23 +490,49 @@ The package re-exports commonly needed utilities so you don't need to install th
 ```typescript
 import {
   Type,                   // from @sinclair/typebox
+  type Static,            // from @sinclair/typebox
   ConditionBuilder,       // from node-condition-builder
   Expression,             // from node-condition-builder
-  QueryClient,            // raw SQL query helper
+
+  // Table configuration
   defineTable,
   exportTableInfo,
   buildRelation,
   buildUpsertRule,
   buildUpsertRules,
+
+  // DB layer
+  QueryClient,            // raw SQL query helper
+  createQueryClient,      // factory with dialect string
+  pgQueryable,            // pg pool adapter
+  mysqlQueryable,         // mysql2 pool adapter
+
+  // Programmatic high-level API
+  createSqlApi,           // standalone SqlApi (for scripts/tests)
+  setupSwagger,           // manual Swagger registration
+} from 'fastify-auto-sqlapi';
+
+import type {
+  ValidationError,        // [field, code] | [field, code, message]
+  ValidatorFn,
+  BulkValidatorFn,
+  JoinRefFilter,
+  JoinGroupRequest,
+  SearchCondition,
+  ConditionMethod,
 } from 'fastify-auto-sqlapi';
 ```
 
+After registering the plugin, `app.sqlApi` is decorated on the Fastify instance and exposes `search`, `get`, `insert`, `update`, `delete`, `bulkUpsert`, `bulkDelete` for custom routes — same code path as the auto-generated endpoints.
+
 ## Requirements
 
 - Node.js >= 18
-- PostgreSQL
-- Fastify >= 4
-- `@fastify/postgres` >= 5
+- Fastify >= 4 (peer dependency)
+- One of:
+  - **PostgreSQL** + `pg` + `@fastify/postgres`
+  - **MySQL** / **MariaDB** + `mysql2`
+- Optional: `@fastify/swagger` + `@fastify/swagger-ui` for Swagger UI
 
 ## License
 

package/dist/bin/generate-schema.js

@@ -6,7 +6,6 @@ import { buildConnectionString, introspectTables } from '../lib/cli/pg-introspec
 import { buildMysqlConnectionConfig, introspectMysqlTables } from '../lib/cli/mysql-introspect.js';
 import { buildTableMap, generateSchemaFile } from '../lib/cli/schema-codegen.js';
 import { loadEnvFile, CONSOLE_COLORS, display, displayAsTableRow, error } from './utils.js';
-loadEnvFile();
 function parseCliArgs() {
     const args = process.argv.slice(2);
     const result = {};
@@ -27,6 +26,7 @@ async function main() {
     display('++++++ fastify-auto-sqlapi: generating schemas ++++++', CONSOLE_COLORS.yellow);
     const cliArgs = parseCliArgs();
     const config = await loadConfig();
+    loadEnvFile(config.envFile);
     const dialect = (cliArgs.dialect || config.dialect || 'postgres');
     const schema = config.schema || (dialect === 'postgres' ? 'public' : config.schema || 'public');
     const outputDir = path.resolve(process.cwd(), cliArgs.output || config.outputDir);
@@ -67,10 +67,10 @@ async function main() {
     let untouched = 0;
     const generatedFiles = new Set();
     for (const schemaName of Object.keys(tableMap)) {
-        const { name: tableName, fields } = tableMap[schemaName];
+        const { name: tableName, fields, colMap } = tableMap[schemaName];
         const filename = path.join(schemasDir, `${schemaName}.ts`);
         generatedFiles.add(`${schemaName}.ts`);
-        const content = generateSchemaFile(schemaName, tableName, fields);
+        const content = generateSchemaFile(schemaName, tableName, fields, colMap);
         let status = 'created';
         let color = CONSOLE_COLORS.green;
         if (fs.existsSync(filename)) {

package/dist/bin/generate-tables.js

@@ -4,7 +4,6 @@ import * as path from 'node:path';
 import { loadConfig } from '../lib/cli/config.js';
 import { parseSchemaFile, generateSingleTableFile, generateDbTablesIndex } from '../lib/cli/tables-codegen.js';
 import { loadEnvFile, CONSOLE_COLORS, display, displayAsTableRow, error } from './utils.js';
-loadEnvFile();
 function printHelp() {
     console.log('');
     display('Usage:', CONSOLE_COLORS.yellow);
@@ -53,9 +52,10 @@ async function main() {
     }
     display('++++++ fastify-auto-sqlapi: generating tables template ++++++', CONSOLE_COLORS.yellow);
     const config = await loadConfig();
+    loadEnvFile(config.envFile);
     const outputDir = path.resolve(process.cwd(), cliArgs.output || config.outputDir);
-    const schemasDir = outputDir;
-    const tablesDir = outputDir;
+    const schemasDir = path.join(outputDir, 'schemas');
+    const tablesDir = path.join(outputDir, 'tables');
     if (!fs.existsSync(schemasDir)) {
         error(`Schemas directory not found: ${schemasDir}`);
         display('Run sqlapi-generate-schema first.', CONSOLE_COLORS.magenta);

package/dist/bin/utils.d.ts

@@ -2,7 +2,7 @@
  * Load .env file from cwd if it exists.
  * Does not override already-set environment variables.
  */
-export declare function loadEnvFile(): void;
+export declare function loadEnvFile(envFile?: string): void;
 export declare const CONSOLE_COLORS: {
     readonly black: 30;
     readonly gray: 90;

package/dist/bin/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/bin/utils.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAqBlC;AAED,eAAO,MAAM,cAAc;;;;;;;;CAQjB,CAAC;AAEX,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,GAAE,MAAU,GAChB,IAAI,CAQN;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,IAAI,CAE7D;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAExC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/bin/utils.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAqBlD;AAED,eAAO,MAAM,cAAc;;;;;;;;CAQjB,CAAC;AAEX,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,GAAE,MAAU,GAChB,IAAI,CAQN;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,IAAI,CAE7D;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAExC"}

package/dist/bin/utils.js

@@ -4,8 +4,8 @@ import { resolve } from 'node:path';
  * Load .env file from cwd if it exists.
  * Does not override already-set environment variables.
  */
-export function loadEnvFile() {
-    const envPath = resolve(process.cwd(), '.env');
+export function loadEnvFile(envFile) {
+    const envPath = resolve(process.cwd(), envFile || '.env');
     if (!existsSync(envPath))
         return;
     const content = readFileSync(envPath, 'utf-8');

package/dist/lib/cli/mysql-introspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mysql-introspect.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/mysql-introspect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,0BAA0B,IAAI;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAmBA;AAkDD,wBAAsB,qBAAqB,CACzC,gBAAgB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAClG,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,UAAU,EAAE,CAAC,CAiCvB"}
+{"version":3,"file":"mysql-introspect.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/mysql-introspect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,0BAA0B,IAAI;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAmBA;AAkDD,wBAAsB,qBAAqB,CACzC,gBAAgB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAClG,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,UAAU,EAAE,CAAC,CAuCvB"}

package/dist/lib/cli/mysql-introspect.js

@@ -67,7 +67,8 @@ function mapMysqlType(dataType) {
 }
 export async function introspectMysqlTables(connectionConfig, schema) {
     // Dynamic import: mysql2 is optional peer dependency.
-    // Use createRequire from cwd so it works with npm link.
+    // Try the consumer's CWD first (so it works when installed), then fall back to
+    // the plugin's own node_modules (so it works in the plugin's own tests).
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let mysql2;
     try {
@@ -75,7 +76,13 @@ export async function introspectMysqlTables(connectionConfig, schema) {
         mysql2 = require('mysql2/promise');
     }
     catch {
-        throw new Error('mysql2 is required for MySQL/MariaDB introspection. Install it with: npm install mysql2');
+        try {
+            const require = createRequire(import.meta.url);
+            mysql2 = require('mysql2/promise');
+        }
+        catch {
+            throw new Error('mysql2 is required for MySQL/MariaDB introspection. Install it with: npm install mysql2');
+        }
     }
     const connection = await mysql2.createConnection(connectionConfig);
     try {

package/dist/lib/cli/schema-codegen.d.ts

@@ -4,5 +4,5 @@ export declare function convertColType(udtName: string, columnInfo: {
     is_nullable: string;
 }): string;
 export declare function buildTableMap(rows: ColumnInfo[]): TableMap;
-export declare function generateSchemaFile(schemaName: string, tableName: string, fields: Record<string, string>): string;
+export declare function generateSchemaFile(schemaName: string, tableName: string, fields: Record<string, string>, colMap: Record<string, string>): string;
 //# sourceMappingURL=schema-codegen.d.ts.map

package/dist/lib/cli/schema-codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-codegen.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/schema-codegen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE3D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE;IAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACjE,MAAM,CAoDR;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,QAAQ,CAkB1D;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAsCR"}
+{"version":3,"file":"schema-codegen.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/schema-codegen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE3D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE;IAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACjE,MAAM,CAoDR;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,QAAQ,CAqB1D;AAED,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CA2CR"}

package/dist/lib/cli/schema-codegen.js

@@ -57,20 +57,26 @@ export function buildTableMap(rows) {
             acc[schemaName] = {
                 name: row.table_name,
                 fields: {},
+                colMap: {},
             };
         }
-        acc[schemaName].fields[toCamelCase(row.column_name)] = convertColType(row.udt_name, row);
+        const fieldName = toCamelCase(row.column_name);
+        acc[schemaName].fields[fieldName] = convertColType(row.udt_name, row);
+        acc[schemaName].colMap[fieldName] = row.column_name;
         return acc;
     }, {});
 }
-export function generateSchemaFile(schemaName, tableName, fields) {
+export function generateSchemaFile(schemaName, tableName, fields, colMap) {
     const fieldsStr = JSON.stringify(fields, null, 2).replace(/"(.*?)"\s*:\s*"Type(.*?)"/g, '$1: Type$2');
+    const colMapStr = JSON.stringify(colMap, null, 2);
     return `// Auto-generated by fastify-auto-sqlapi. Do not edit.
-import { Type, toUnderscore } from "fastify-auto-sqlapi";
+import { Type } from "fastify-auto-sqlapi";
 import type { Static } from "fastify-auto-sqlapi";
 
 const _Schema = ${fieldsStr};
 
+const _colMap: Record<string, string> = ${colMapStr};
+
 const validation = Type.Object(_Schema, { $id: "${schemaName}" });
 const partialValidation = Type.Object(
   Object.fromEntries(
@@ -83,7 +89,8 @@ const partialValidation = Type.Object(
 );
 
 export const Schema = {
-  col: (f: keyof typeof _Schema) => toUnderscore(f),
+  col: (f: keyof typeof _Schema) => _colMap[f as string] ?? f,
+  colMap: _colMap,
   fields: _Schema,
   validation,
   tableName: "${tableName}",

package/dist/lib/cli/tables-codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tables-codegen.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/tables-codegen.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CA2BpE;AAgBD,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,gBAAgB,EAAE,CAwB3E;AAID,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,MAAM,CAuHhG;AAID,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAqBrE;AAID,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CA6FlE"}
+{"version":3,"file":"tables-codegen.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/tables-codegen.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CA2BpE;AAgBD,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,gBAAgB,EAAE,CAwB3E;AAID,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,MAAM,CAwHhG;AAID,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAqBrE;AAID,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CA6FlE"}

package/dist/lib/cli/tables-codegen.js

@@ -98,6 +98,7 @@ export function generateSingleTableFile(schema, allSchemas) {
     const lines = [];
     // Imports
     lines.push(`import {defineTable, exportTableInfo, Type} from 'fastify-auto-sqlapi';`);
+    lines.push(`import type {ValidationError} from 'fastify-auto-sqlapi';`);
     lines.push(`import {${schema.schemaName} as Schema} from '../schemas/${schema.schemaName}';`);
     // Commented imports for related schemas
     for (const relSchema of relatedSchemas) {
@@ -157,7 +158,7 @@ export function generateSingleTableFile(schema, allSchemas) {
     // validate: use first non-PK field for example
     const exampleField = schema.fields.find(f => f !== pk) || schema.fields[0];
     lines.push(`  validate: async (db, req, main, secondaries) => {`);
-    lines.push(`    const errors = [];`);
+    lines.push(`    const errors: ValidationError[] = [];`);
     lines.push(`    // if (!main.${exampleField}) errors.push(['${exampleField}', 'required']);`);
     lines.push(`    return errors;`);
     lines.push(`  },`);
@@ -209,7 +210,7 @@ export function generateTablesFile(schemas) {
     const lines = [];
     // Imports
     lines.push(`import {defineTable, exportTableInfo, Type} from 'fastify-auto-sqlapi';`);
-    lines.push(`import type { DbTables } from 'fastify-auto-sqlapi';`);
+    lines.push(`import type { DbTables, ValidationError } from 'fastify-auto-sqlapi';`);
     lines.push(``);
     // Schema imports
     for (const schema of schemas) {
@@ -247,7 +248,7 @@ export function generateTablesFile(schemas) {
         lines.push(`  // schemaOverrides: {},`);
         const exampleFieldLegacy = schema.fields.find(f => f !== pk) || schema.fields[0];
         lines.push(`  validate: async (db, req, main, secondaries) => {`);
-        lines.push(`    const errors = [];`);
+        lines.push(`    const errors: ValidationError[] = [];`);
         lines.push(`    // if (!main.${exampleFieldLegacy}) errors.push(['${exampleFieldLegacy}', 'required']);`);
         lines.push(`    return errors;`);
         lines.push(`  },`);