nuxt-auto-crud 2.2.0 → 2.4.0

package/README.md

@@ -1,4 +1,4 @@
-# nuxt-auto-crud (nac 2.x)
+# nuxt-auto-crud (nac 2.x beta)
 
 **Zero-Codegen Dynamic RESTful CRUD APIs** derived directly from schemas. It eliminates the need to manually write or generate boilerplate for CRUD operations.
 
@@ -11,13 +11,25 @@
 * **Constant Bundle Size**: Since no code is generated, the bundle size remains virtually identical whether you have one table or one hundred (scaling only with your schema definitions).
 ---
 
+## Supported Databases
+* **SQLite (libSQL)**
+* **MySQL**
+
+---
+
 ## Installation Guide
 
 ### Option A: Starter Template
+#### SQLite
 ```bash
 npx nuxi init -t gh:clifordpereira/nac-starter my-app
 ```
 
+#### MySQL
+```bash
+npx nuxi init -t gh:clifordpereira/nac-starter-mysql my-app
+```
+
 ### Option B: Manual Installation
 
 ```bash
@@ -27,6 +39,7 @@ bun add drizzle-orm@beta @libsql/client nuxt-auto-crud
 bun add -D drizzle-kit@beta
 
 ```
+> Mysql users may replace `@libsql/client` with `mysql2`
 
 #### Configuration
 
@@ -40,12 +53,13 @@ export default defineNuxtConfig({
   ],
   hub: {
     db: 'sqlite'
+    // db: 'mysql'
   }
 })
 
 ```
 
-#### Schema Definition
+#### Schema Definition (SQLite)
 
 Define your schema in `server/db/schema.ts`:
 
@@ -63,6 +77,24 @@ export const users = sqliteTable('users', {
 
 ```
 
+#### Schema Definition (MySQL)
+
+Define your schema in `server/db/schema.ts`:
+
+```typescript
+import { mysqlTable, text, serial, timestamp } from 'drizzle-orm/mysql-core'
+
+export const users = mysqlTable('users', {
+  id: serial().primaryKey(),
+  name: text().notNull(),
+  email: text().notNull().unique(),
+  password: text().notNull(),
+  avatar: text().notNull(),
+  createdAt: timestamp().notNull().defaultNow(),
+})
+
+```
+
 ### Generate Migrations and Start Dev Server
 After installing (either option), run the following commands:
 
@@ -76,9 +108,9 @@ nuxt dev
 
 ---
 
-## 🌐 Exposed Dynamic RESTful CRUD endpoints
+## 🌐 Data APIs (Dynamic RESTful CRUD)
 
-Nb: Endpoints follow the pattern `/api/_nac/:model`.
+> Note: All endpoints follow the pattern ${nacEndpointPrefix}/:model. By default, this is /api/_nac/:model.
 
 | Method | Endpoint | Action |
 | --- | --- | --- |
@@ -86,7 +118,8 @@ Nb: Endpoints follow the pattern `/api/_nac/:model`.
 | **POST** | `/:model` | Create record with Zod validation |
 | **GET** | `/:model/:id` | Fetch single record |
 | **PATCH** | `/:model/:id` | Partial update with validation |
-| **DELETE** | `/:model/:id` | Hard delete |
+| **DELETE** | `/:model/:id` | Delete record |
+
 
 **Example (`users` table):** 
 
@@ -96,18 +129,27 @@ Nb: Endpoints follow the pattern `/api/_nac/:model`.
 | **Create** | `POST` | `/api/_nac/users` | New user record added |
 | **Fetch One** | `GET` | `/api/_nac/users/1` | Details of user with `id: 1` |
 | **Update** | `PATCH` | `/api/_nac/users/1` | Partial update to user `1` |
-| **Delete** | `DELETE` | `/api/_nac/users/1` | User `1` hard deleted from DB |
+| **Delete** | `DELETE` | `/api/_nac/users/1` | User `1` removed from DB |
 
 ---
 
-## 🛠 Frontend Integration APIs
+## 🛠 Introspection & Metadata APIs
 
-In addition to CRUD endpoints, **nac** provides metadata APIs to power dynamic forms and tables in your frontend.
+Use these endpoints to build dynamic UI components (like menus and forms) or provide context to AI agents. These use the `_schemas` and `_meta` reserved paths.
 
-* **List Resources**: `GET /api/_nac/_schemas` returns all tables (excluding system-protected tables).
-* **Resource Metadata**: `GET /api/_nac/_schemas/:resource` returns the field definitions, validation rules, and relationship data for a specific table.
+### 1. Discovery Endpoints
 
----
+* **List Resource Names**: `GET /api/_nac/_schemas`
+* Returns an array of all available table names. Useful for generating dynamic navigation menus.
+* **Resource Metadata**: `GET /api/_nac/_schemas/:resource`
+* Returns field definitions, validation rules, and `isReadOnly` status for a specific table.
+* **Example:** `GET /api/_nac/_schemas/users` returns the schema for the users table.
+
+### 2. Agentic Discovery
+
+* **Manifest**: `GET /api/_nac/_meta?format=md`
+* Returns a token-efficient Markdown manifest for LLM context injection.
+* **Security:** Requires `NUXT_AUTO_CRUD_AGENTIC_TOKEN` (min 16 characters) in your `.env`.
 
 ### Schema Interface
 
@@ -153,8 +195,9 @@ Enabling `authentication` in the `autoCrud` config protects all **nac** routes (
 
 ### 🔒 Access Control & Data Safety
 
-* **`apiHiddenFields`**: Globally hides sensitive columns from all API responses. Default: `['password', 'secret', 'token', 'reset_token', 'reset_expires', 'github_id', 'google_id']`.
-* **`formHiddenFields`**: Columns excluded from the frontend schema metadata to prevent user input. Defaults to `apiHiddenFields` plus system-managed fields like `id`, `uuid`, `createdAt`, `updatedAt`, `createdBy`, etc.
+* **`apiHiddenFields`**: Globally hides sensitive columns from all API responses. Default: ['password', 'secret', 'token', 'resetToken', 'resetExpires', 'githubId', 'googleId'].
+* **`formHiddenFields`**: Columns excluded from the frontend schema metadata to prevent user input. Defaults to apiHiddenFields plus system-managed fields like `id`, `uuid`, `createdAt`, `updatedAt`, `deletedAt`, `createdBy`, and `updatedBy`.
+* **`formReadOnlyFields`**: Columns visible in the UI for context but protected from user modification (e.g., slug, status).
 * **Response Scrubbing**: If a field is in `apiHiddenFields` or does not exist in the schema, it is silently stripped from the response even if listed in `publicResources`.
 
 ---
@@ -164,11 +207,15 @@ Enabling `authentication` in the `autoCrud` config protects all **nac** routes (
 | Key | Default | Description |
 | --- | --- | --- |
 | `statusFiltering` | `false` | Enables/disables automatic filtering of records based on the `status` column. |
-| `realtime` | `false` | Enables/disables real-time capabilities. |
-| `auth.authentication` | `true` | Requires a valid session for all NAC routes. |
-| `auth.authorization` | `true` | Enables role/owner-based access checks. |
+| `realtime` | `false` | Enables real-time broadcasting of all Create, Update, and Delete (CUD) operations via SSE. |
+| `auth.authentication` | `false` | Requires a valid session for all NAC routes. |
+| `auth.authorization` | `false` | Enables role/owner-based access checks. |
 | `auth.ownerKey` | `'createdBy'` | The column name used to identify the record creator. |
 | `publicResources` | `{}` | Defines tables and specific columns accessible without auth. |
+| `apiHiddenFields` | `NAC_API_HIDDEN_FIELDS` | Arrays of keys to exclude from all API responses. |
+| `formHiddenFields` | `NAC_FORM_HIDDEN_FIELDS` | Arrays of keys to exclude from dynamic forms. |
+| `formReadOnlyFields` | `NAC_FORM_READ_ONLY_FIELDS` | List of visible but non-editable fields (UI only). |
+| `agenticToken` | `''` | Secret key used to secure the /_meta endpoint, preventing unauthorized AI agents from introspecting your schema. |
 | `nacEndpointPrefix` | `'/api/_nac'` | The base path for NAC routes. Access via `useRuntimeConfig().public.autoCrud`. |
 | `schemaPath` | `'server/db/schema'` | Location of your Drizzle schema files. |
 
@@ -179,16 +226,17 @@ autoCrud: {
   statusFiltering: false,
   realtime: false,
   auth: {
-    authentication: true,
-    authorization: true,
+    authentication: false,
+    authorization: false,
     ownerKey: 'createdBy', 
   },
   publicResources: {
     users: ['id', 'name', 'email'],
   },
   apiHiddenFields: ['password'], 
-  agenticToken: process.env.NAC_AGENTIC_TOKEN, 
-  formHiddenFields: [], 
+  formHiddenFields: ['createdAt'], // All fields should be camelCase
+  formReadOnlyFields: ['slug', 'externalId'], // Locked for user input
+  agenticToken: '', 
   nacEndpointPrefix: '/api/_nac',
   schemaPath: 'server/db/schema',
 }
@@ -219,7 +267,7 @@ If `list_active` is present, it applies a hybrid OR logic: users can see all act
 // Example: Setting context in your Auth Middleware
 event.context.nac = {
   userId: user.id,
-  resourcePermissions: user.permissions[model], // e.g., ['list_own', 'list']
+  resourcePermissions: user.permissions[model], // e.g., ['list_own', 'list_active']
   record: null, // Optional: Pre-fetched record to prevent double-hitting the DB
 }
 
@@ -272,7 +320,3 @@ useNacAutoCrudSSE(({ table, action, data: sseData, primaryKey }) => {
 ```
 ---
 
-## ⚠️ Limitations
-**Database Support:** Currently optimized for SQLite/libSQL only.
-
----

package/dist/module.d.mts

@@ -14,13 +14,14 @@ interface ModuleOptions {
     publicResources: Record<string, string[]>; /** Allowed fields for public apis */
     nacEndpointPrefix: string;
     formHiddenFields: string[]; /** UI: Hidden from forms */
+    formReadOnlyFields: string[]; /** UI: Read only fields */
 }
 declare module '@nuxt/schema' {
     interface RuntimeConfig {
-        autoCrud: Omit<ModuleOptions, 'nacEndpointPrefix' | 'formHiddenFields'>;
+        autoCrud: Omit<ModuleOptions, 'nacEndpointPrefix' | 'formHiddenFields' | 'formReadOnlyFields'>;
     }
     interface PublicRuntimeConfig {
-        autoCrud: Pick<ModuleOptions, 'nacEndpointPrefix' | 'formHiddenFields'>;
+        autoCrud: Pick<ModuleOptions, 'nacEndpointPrefix' | 'formHiddenFields' | 'formReadOnlyFields'>;
     }
 }
 

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-auto-crud",
   "configKey": "autoCrud",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { defineNuxtModule, createResolver, addImportsDir, addServerImportsDir, addServerHandler } from '@nuxt/kit';
-import { NAC_FORM_HIDDEN_FIELDS, NAC_API_HIDDEN_FIELDS } from '../dist/runtime/server/utils/constants.js';
+import { NAC_FORM_READ_ONLY_FIELDS, NAC_FORM_HIDDEN_FIELDS, NAC_API_HIDDEN_FIELDS } from '../dist/runtime/server/utils/constants.js';
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -21,6 +21,7 @@ const module$1 = defineNuxtModule({
     schemaPath: "server/db/schema",
     // Public config
     formHiddenFields: NAC_FORM_HIDDEN_FIELDS,
+    formReadOnlyFields: NAC_FORM_READ_ONLY_FIELDS,
     nacEndpointPrefix: "/api/_nac"
   },
   async setup(options, nuxt) {
@@ -29,9 +30,9 @@ const module$1 = defineNuxtModule({
     nuxt.options.alias["#nac/shared"] = resolver.resolve("./runtime/shared");
     nuxt.options.alias["#nac/types"] = resolver.resolve("./runtime/server/types");
     nuxt.options.alias["#nac/schema"] = resolver.resolve(nuxt.options.rootDir, options.schemaPath);
-    const { formHiddenFields, nacEndpointPrefix, ...privateOptions } = options;
+    const { formHiddenFields, nacEndpointPrefix, formReadOnlyFields, ...privateOptions } = options;
     nuxt.options.runtimeConfig.autoCrud = privateOptions;
-    nuxt.options.runtimeConfig.public.autoCrud = { formHiddenFields, nacEndpointPrefix };
+    nuxt.options.runtimeConfig.public.autoCrud = { formHiddenFields, nacEndpointPrefix, formReadOnlyFields };
     addImportsDir(resolver.resolve("./runtime/composables"));
     addServerImportsDir(resolver.resolve("./runtime/server/utils"));
     nuxt.hook("prepare:types", ({ references }) => {

package/dist/runtime/server/api/_nac/_meta.get.d.ts

@@ -1,12 +1,21 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | {
     architecture: string;
     version: string;
-    resources: ({
+    resources: {
         resource: string;
         endpoint: string;
-        labelField: any;
+        labelField: string;
         methods: string[];
-        fields: any;
-    } | null)[];
+        fields: {
+            name: string;
+            type: string;
+            required: boolean | undefined;
+            isEnum: boolean;
+            options: string[] | null;
+            references: string | null;
+            isRelation: boolean;
+            isReadOnly: boolean;
+        }[];
+    }[];
 }>>;
 export default _default;

package/dist/runtime/server/api/_nac/_meta.get.js

@@ -1,5 +1,5 @@
 import { db } from "@nuxthub/db";
-import { eventHandler, getQuery, getHeader } from "h3";
+import { eventHandler, getQuery, getHeader, setResponseHeader } from "h3";
 import { useRuntimeConfig } from "#imports";
 import { getSchemaDefinition, modelTableMap } from "../../utils/modelMapper.js";
 export default eventHandler(async (event) => {
@@ -9,9 +9,9 @@ export default eventHandler(async (event) => {
   const acceptHeader = getHeader(event, "accept") || "";
   const availableModels = Object.keys(modelTableMap);
   const models = availableModels.length > 0 ? availableModels : Object.keys(db?.query || {});
-  const resources = models.map((model) => {
+  const resourcesResults = await Promise.all(models.map(async (model) => {
     try {
-      const schema = getSchemaDefinition(model);
+      const schema = await getSchemaDefinition(model);
       const fields = schema.fields.map((field) => ({
         name: field.name,
         type: field.type,
@@ -32,13 +32,15 @@ export default eventHandler(async (event) => {
     } catch {
       return null;
     }
-  }).filter(Boolean);
+  }));
+  const resources = resourcesResults.filter((res) => res !== null);
   const payload = {
     architecture: "Clifland-NAC",
     version: "1.0.0-agentic",
     resources
   };
   if (query.format === "md" || acceptHeader.includes("text/markdown")) {
+    setResponseHeader(event, "Content-Type", "text/markdown; charset=utf-8");
     let markdown = `# ${payload.architecture} API Manifest (v${payload.version})
 
 `;

package/dist/runtime/server/api/_nac/_schemas/[model].get.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../../../shared/utils/types.js").SchemaDefinition>>;
 export default _default;

package/dist/runtime/server/middleware/nac-guard.js

@@ -12,7 +12,7 @@ export default defineEventHandler(async (event) => {
     const isUserAuthenticated = Boolean(event.context.nac?.userId);
     if (isAuthEnabled && !isUserAuthenticated) {
       const model = getModelName(pathname, nacEndpointPrefix);
-      if (model && isPublicResource(model)) {
+      if (model && isPublicResource(model, config.autoCrud.publicResources)) {
         event.context.nac.isPublic = true;
       } else {
         throw new AuthenticationError("Unauthorized").toH3();
@@ -22,18 +22,26 @@ export default defineEventHandler(async (event) => {
   }
   const token = getQuery(event).token;
   const { agenticToken } = config.autoCrud;
-  if (!agenticToken || token !== agenticToken) {
+  if (!validateToken(token, agenticToken)) {
     throw new AuthenticationError("Invalid agentic token").toH3();
   }
 });
+function validateToken(token, agenticToken) {
+  if (!token || !agenticToken || agenticToken.length < 16) return false;
+  if (token.length !== agenticToken.length) return false;
+  let diff = 0;
+  for (let i = 0; i < token.length; i++) {
+    diff |= token.charCodeAt(i) ^ agenticToken.charCodeAt(i);
+  }
+  return diff === 0;
+}
 function getModelName(pathname, nacEndpointPrefix) {
   const regex = new RegExp(`^${nacEndpointPrefix}/([^/]+)`);
   const match = pathname.match(regex);
   return match ? match[1] : null;
 }
-function isPublicResource(model) {
-  const { publicResources } = useRuntimeConfig().autoCrud;
-  return Object.keys(publicResources || {}).includes(model);
+function isPublicResource(model, publicResources = {}) {
+  return Object.keys(publicResources).includes(model);
 }
 function isAgenticPath(pathname) {
   return pathname.includes("/_meta");

package/dist/runtime/server/utils/constants.d.ts

@@ -5,14 +5,19 @@
 export declare const NAC_API_HIDDEN_FIELDS: string[];
 /**
  * 2. FORM_HIDDEN_FIELDS
- * User should not edit these. System handles these.
- * Includes System Fields (minus status/updated_at) + Hidden Fields.
  */
 export declare const NAC_FORM_HIDDEN_FIELDS: string[];
 /**
- * 3. TABLE_HIDDEN_FIELDS
- * UI clutter reduction for DataTables.
+ * 3. DATA_TABLE_HIDDEN_FIELDS
  */
 export declare const NAC_DATA_TABLE_HIDDEN_FIELDS: string[];
-/** Tables used by the underlying database engine/migration tool */
+/**
+ * 4. FORM_READ_ONLY_FIELDS
+ * Visible in forms for context, but not editable.
+ */
+export declare const NAC_FORM_READ_ONLY_FIELDS: never[];
+/**
+ * Tables used by the engine.
+ * These match the actual DB table names (usually snake_case or specific migration names).
+ */
 export declare const NAC_SYSTEM_TABLES: string[];

package/dist/runtime/server/utils/constants.js

@@ -1,32 +1,27 @@
-const NAC_SYSTEM_FIELDS = [
-  "id",
-  "uuid",
-  "created_at",
-  "updated_at",
-  "deleted_at",
-  "created_by",
-  "updated_by"
-];
 export const NAC_API_HIDDEN_FIELDS = [
   "password",
   "secret",
   "token",
-  "reset_token",
-  "reset_expires",
-  "github_id",
-  "google_id"
+  "resetToken",
+  "resetExpires",
+  "githubId",
+  "googleId"
 ];
 export const NAC_FORM_HIDDEN_FIELDS = [
-  // ...NAC_API_HIDDEN_FIELDS, // hidden by default.
-  ...NAC_SYSTEM_FIELDS
-  // from the api, hide system fields too
+  ...NAC_API_HIDDEN_FIELDS,
+  "id",
+  "uuid",
+  "createdAt",
+  "updatedAt",
+  "deletedAt",
+  "createdBy",
+  "updatedBy"
 ];
 export const NAC_DATA_TABLE_HIDDEN_FIELDS = [
-  // ...NAC_API_HIDDEN_FIELDS, // hidden by default.
-  "updated_at",
-  "deleted_at",
-  "created_by",
-  "updated_by"
-  // from the api, hide these fields too
+  "updatedAt",
+  "deletedAt",
+  "createdBy",
+  "updatedBy"
 ];
+export const NAC_FORM_READ_ONLY_FIELDS = [];
 export const NAC_SYSTEM_TABLES = ["_hub_migrations", "d1_migrations", "sqlite_sequence"];

package/dist/runtime/server/utils/modelMapper.d.ts

@@ -1,8 +1,7 @@
 import { type Column, Table } from 'drizzle-orm';
-import { getTableConfig } from 'drizzle-orm/sqlite-core';
-import type { SchemaDefinition } from '#nac/shared/utils/types';
+import type { ForeignKey } from 'drizzle-orm/sqlite-core';
+import type { SchemaDefinition } from '../../shared/utils/types.js';
 import type { QueryContext } from '../../types/index.js';
-type ForeignKey = ReturnType<typeof getTableConfig>['foreignKeys'][number];
 /**
  * Builds a map of all exported Drizzle tables from the schema.
  * @returns {Record<string, Table>} A mapping of export keys to their corresponding Table instances.
@@ -26,7 +25,7 @@ export declare function getSelectableFields(table: Table, context?: QueryContext
  * Resolves table relationships for NAC reflection.
  * Maps property keys to target table names.
  */
-export declare function resolveTableRelations(table: Table): Record<string, string>;
+export declare function resolveTableRelations(table: Table): Promise<Record<string, string>>;
 /**
  * Resolves the label field for a model.
  * @param columnNames The names of the columns in the model
@@ -40,5 +39,4 @@ export declare function getLabelField(columnNames: string[]): string;
  * - Infers types from Drizzle columns
  * - Resolves foreign key relations
  */
-export declare function getSchemaDefinition(modelName: string): SchemaDefinition;
-export {};
+export declare function getSchemaDefinition(modelName: string): Promise<SchemaDefinition>;

package/dist/runtime/server/utils/modelMapper.js

@@ -1,5 +1,4 @@
 import { getColumns, Table, is, getTableName } from "drizzle-orm";
-import { getTableConfig } from "drizzle-orm/sqlite-core";
 import { createInsertSchema } from "drizzle-zod";
 import { useRuntimeConfig } from "#imports";
 import * as schema from "#nac/schema";
@@ -42,7 +41,11 @@ export function getSelectableFields(table, context = {}) {
   }
   return result;
 }
-export function resolveTableRelations(table) {
+export async function resolveTableRelations(table) {
+  const { hub } = useRuntimeConfig();
+  const dbConfig = hub.db;
+  const isMysql = dbConfig === "mysql" || typeof dbConfig === "object" && dbConfig?.dialect === "mysql";
+  const { getTableConfig } = await (isMysql ? import("drizzle-orm/mysql-core") : import("drizzle-orm/sqlite-core"));
   const config = getTableConfig(table);
   const columnsMap = getColumns(table);
   const relations = {};
@@ -68,16 +71,16 @@ const SEMANTIC_CHECK_MAP = {
   url: "url"
 };
 const TEXTAREA_HINTS = ["content", "description", "bio", "message"];
-export function getSchemaDefinition(modelName) {
+export async function getSchemaDefinition(modelName) {
   const table = modelTableMap[modelName];
   if (!table) throw new ResourceNotFoundError(modelName);
   const config = useRuntimeConfig();
   const apiHiddenFields = config.autoCrud.apiHiddenFields;
-  const formHiddenFields = config.public.autoCrud.formHiddenFields;
+  const { formHiddenFields, formReadOnlyFields } = config.public.autoCrud;
   const columns = getColumns(table);
-  const relations = resolveTableRelations(table);
+  const relations = await resolveTableRelations(table);
   const shape = createInsertSchema(table).shape;
-  const fields = Object.entries(columns).filter(([name]) => !apiHiddenFields.includes(name)).map(([name, col]) => {
+  const fields = Object.entries(columns).filter(([name]) => !apiHiddenFields.includes(name) && !formHiddenFields.includes(name)).map(([name, col]) => {
     const zodField = shape[name];
     const zodTypeName = zodField?._def?.typeName;
     let type = ZOD_TYPE_MAP[zodTypeName] ?? "string";
@@ -102,7 +105,7 @@ export function getSchemaDefinition(modelName) {
       selectOptions,
       required: colInternal.notNull ?? false,
       references: relations[name],
-      isReadOnly: formHiddenFields.includes(name)
+      isReadOnly: formReadOnlyFields.includes(name) || name === "id"
     };
   });
   return {

package/dist/runtime/server/utils/queries.js

@@ -4,6 +4,11 @@ import { eq, desc, and, or, getColumns } from "drizzle-orm";
 import { getSelectableFields } from "./modelMapper.js";
 import { DeletionFailedError, InsertionFailedError, RecordNotFoundError, UnauthorizedAccessError, UpdateFailedError } from "../exceptions.js";
 import { pick } from "#nac/shared/utils/helpers";
+function isMysql() {
+  const hub = useRuntimeConfig().hub;
+  const dbConfig = hub?.db;
+  return dbConfig === "mysql" || typeof dbConfig === "object" && dbConfig?.dialect === "mysql";
+}
 export function getVisibilityFilters(table, context = {}) {
   const isAuthorizationEnabled = useRuntimeConfig().autoCrud.auth?.authorization;
   const isStatusFilteringEnabled = useRuntimeConfig().autoCrud.statusFiltering;
@@ -46,14 +51,19 @@ export async function nacGetRows(table, context = {}) {
   let query = db.select(fields).from(table).$dynamic();
   const filters = getVisibilityFilters(table, context);
   if (filters.length > 0) query = query.where(and(...filters));
-  return await query.orderBy(desc(table.id)).all();
+  const baseQuery = query.orderBy(desc(table.id));
+  if (isMysql()) {
+    return await baseQuery;
+  }
+  return await baseQuery.all();
 }
 export async function nacGetRow(table, id, context = {}) {
   const selectableFields = getSelectableFields(table, context);
   if (context.record) {
     return pick(context.record, Object.keys(selectableFields));
   }
-  const record = await db.select(selectableFields).from(table).where(eq(table.id, Number(id))).get();
+  const query = db.select(selectableFields).from(table).where(eq(table.id, Number(id)));
+  const record = isMysql() ? (await query)[0] : await query.get();
   if (!record) throw new RecordNotFoundError();
   return record;
 }
@@ -69,6 +79,11 @@ export async function nacCreateRow(table, data, context = {}) {
   if ("updatedAt" in allColumns) {
     payload.updatedAt = /* @__PURE__ */ new Date();
   }
+  if (isMysql()) {
+    const [res] = await db.insert(table).values(payload);
+    const rows = await db.select(selectableFields).from(table).where(eq(table.id, res.insertId));
+    return rows[0];
+  }
   const result = await db.insert(table).values(payload).returning(selectableFields).get();
   if (!result) throw new InsertionFailedError();
   return result;
@@ -84,6 +99,10 @@ export async function nacUpdateRow(table, id, data, context = {}) {
   if ("updatedAt" in allColumns) {
     payload.updatedAt = /* @__PURE__ */ new Date();
   }
+  if (isMysql()) {
+    await db.update(table).set(payload).where(eq(table.id, targetId));
+    return await nacGetRow(table, id, context);
+  }
   const [updated] = await db.update(table).set(payload).where(eq(table.id, targetId)).returning(selectableFields);
   if (!updated) throw new UpdateFailedError();
   return updated;
@@ -91,6 +110,11 @@ export async function nacUpdateRow(table, id, data, context = {}) {
 export async function nacDeleteRow(table, id) {
   const targetId = Number(id);
   const fields = getSelectableFields(table);
+  if (isMysql()) {
+    const recordToDelete = await nacGetRow(table, id);
+    await db.delete(table).where(eq(table.id, targetId));
+    return recordToDelete;
+  }
   const deletedRecord = await db.delete(table).where(eq(table.id, targetId)).returning(fields).get();
   if (!deletedRecord) throw new DeletionFailedError();
   return deletedRecord;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-auto-crud",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Dynamic RESTful CRUD APIs for Nuxt without code generation, fully schema-driven.",
   "author": "Cliford Pereira",
   "license": "MIT",
@@ -49,11 +49,11 @@
   "dependencies": {
     "@nuxt/kit": "^4.3.1",
     "drizzle-zod": "^0.8.3",
+    "mysql2": "^3.18.2",
     "pluralize": "^8.0.0",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "@libsql/client": "^0.17.0",
     "@nuxthub/core": "^0.10.6",
     "drizzle-kit": ">=1.0.0-beta.0",
     "drizzle-orm": ">=1.0.0-beta.0",