nuxt-auto-crud 1.1.0

package/README.md

@@ -0,0 +1,232 @@
+# Nuxt Auto CRUD
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+Auto-generate RESTful CRUD APIs for your Nuxt app based solely on your database schema. No configuration needed!
+
+- [✨ Release Notes](/CHANGELOG.md)
+- [🎮 Try the Playground](/playground)
+
+## ✨ Features
+
+- 🔄 **Auto-Detection** - Automatically detects all tables from your Drizzle schema
+- 🚀 **Zero Configuration** - Just define your schema, APIs are generated automatically
+- 🛡️ **Protected Fields** - Automatically protects `id` and `createdAt` fields from updates
+- 📝 **Full CRUD** - Complete Create, Read, Update, Delete operations out of the box
+- 🎯 **Type-Safe** - Fully typed with TypeScript support
+- 🔌 **Works with NuxtHub** - Seamlessly integrates with NuxtHub database
+
+## 📦 Quick Setup
+
+### 1. Install the module
+
+```bash
+bun add nuxt-auto-crud
+# or
+npm install nuxt-auto-crud
+```
+
+### 2. Add to your Nuxt config
+
+```typescript
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ["@nuxthub/core", "nuxt-auto-crud"],
+
+  hub: {
+    database: true,
+  },
+
+  autoCrud: {
+    schemaPath: "server/database/schema", // default value
+  },
+});
+```
+
+### 3. Define your database schema
+
+```typescript
+// server/database/schema.ts
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+
+export const users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  name: text("name").notNull(),
+  email: text("email").notNull().unique(),
+  bio: text("bio"),
+  createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(
+    () => new Date()
+  ),
+});
+
+export const posts = sqliteTable("posts", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  title: text("title").notNull(),
+  content: text("content").notNull(),
+  published: integer("published", { mode: "boolean" }).default(false),
+  authorId: integer("author_id").references(() => users.id),
+  createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(
+    () => new Date()
+  ),
+});
+```
+
+That's it! 🎉 Your CRUD APIs are now available:
+
+- `GET /api/users` - List all users
+- `POST /api/users` - Create a new user
+- `GET /api/users/:id` - Get user by ID
+- `PATCH /api/users/:id` - Update user
+- `DELETE /api/users/:id` - Delete user
+
+_(Same endpoints for all your tables!)_
+
+## 🎮 Try the Playground
+
+Want to see it in action? Clone this repo and try the playground:
+
+```bash
+# Clone the repository
+git clone https://github.com/clifordpereira/nuxt-auto-crud.git
+cd nuxt-auto-crud
+
+# Install dependencies
+bun install
+
+# Run the playground
+cd playground
+bun install
+bun run dev
+```
+
+The playground includes a sample schema with users, posts, and comments tables, plus an interactive UI to explore all the features.
+
+## 📖 Usage Examples
+
+### Create a Record
+
+```typescript
+const user = await $fetch("/api/users", {
+  method: "POST",
+  body: {
+    name: "John Doe",
+    email: "john@example.com",
+    bio: "Software developer",
+  },
+});
+```
+
+### Get All Records
+
+```typescript
+const users = await $fetch("/api/users");
+```
+
+### Get Record by ID
+
+```typescript
+const user = await $fetch("/api/users/1");
+```
+
+### Update a Record
+
+```typescript
+const updated = await $fetch("/api/users/1", {
+  method: "PATCH",
+  body: {
+    bio: "Updated bio",
+  },
+});
+```
+
+### Delete a Record
+
+```typescript
+await $fetch("/api/users/1", {
+  method: "DELETE",
+});
+```
+
+## ⚙️ Configuration
+
+### Module Options
+
+```typescript
+export default defineNuxtConfig({
+  autoCrud: {
+    // Path to your database schema file (relative to project root)
+    schemaPath: "server/database/schema", // default
+  },
+});
+```
+
+### Protected Fields
+
+By default, the following fields are protected from updates:
+
+- `id`
+- `createdAt`
+- `created_at`
+
+You can customize updatable fields in your schema by modifying the `modelMapper.ts` utility.
+
+## 🔧 Requirements
+
+- Nuxt 3 or 4
+- NuxtHub (for database functionality)
+- Drizzle ORM
+
+## 🤝 Contributing
+
+Contributions are welcome! Please check out the [contribution guide](/CONTRIBUTING.md).
+
+<details>
+  <summary>Local development</summary>
+  
+  ```bash
+  # Install dependencies
+  bun install
+  
+  # Generate type stubs
+  bun run dev:prepare
+  
+  # Develop with the playground
+  bun run dev
+  
+  # Build the playground
+  bun run dev:build
+  
+  # Run ESLint
+  bun run lint
+  
+  # Run Vitest
+  bun run test
+  bun run test:watch
+  
+  # Release new version
+  bun run release
+  ```
+
+</details>
+
+## 📝 License
+
+[MIT License](./LICENSE)
+
+## 👨‍💻 Author
+
+Made with ❤️ by [Cliford Pereira](https://github.com/clifordpereira)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/nuxt-auto-crud/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/nuxt-auto-crud
+[npm-downloads-src]: https://img.shields.io/npm/dm/nuxt-auto-crud.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/nuxt-auto-crud
+[license-src]: https://img.shields.io/npm/l/nuxt-auto-crud.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/nuxt-auto-crud
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,13 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    /**
+     * Path to the database schema file
+     * @default 'server/database/schema'
+     */
+    schemaPath?: string;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "nuxt-auto-crud",
+  "configKey": "autoCrud",
+  "version": "1.1.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,51 @@
+import { defineNuxtModule, createResolver, addServerHandler, addServerImportsDir } from '@nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-auto-crud",
+    configKey: "autoCrud"
+  },
+  defaults: {
+    schemaPath: "server/database/schema"
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const schemaPath = resolver.resolve(
+      nuxt.options.rootDir,
+      options.schemaPath
+    );
+    nuxt.options.alias["#site/schema"] = schemaPath;
+    const apiDir = resolver.resolve("./runtime/server/api");
+    addServerHandler({
+      route: "/api/:model",
+      method: "get",
+      handler: resolver.resolve(apiDir, "[model]/index.get.ts")
+    });
+    addServerHandler({
+      route: "/api/:model",
+      method: "post",
+      handler: resolver.resolve(apiDir, "[model]/index.post.ts")
+    });
+    addServerHandler({
+      route: "/api/:model/:id",
+      method: "get",
+      handler: resolver.resolve(apiDir, "[model]/[id].get.ts")
+    });
+    addServerHandler({
+      route: "/api/:model/:id",
+      method: "patch",
+      handler: resolver.resolve(apiDir, "[model]/[id].patch.ts")
+    });
+    addServerHandler({
+      route: "/api/:model/:id",
+      method: "delete",
+      handler: resolver.resolve(apiDir, "[model]/[id].delete.ts")
+    });
+    addServerImportsDir(resolver.resolve("./runtime/server/utils"));
+    console.log("\u{1F680} Auto CRUD module loaded!");
+    console.log(`   - Schema: ${options.schemaPath}`);
+    console.log(`   - API: /api/[model]`);
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/server/api/[model]/[id].delete.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/[model]/[id].delete.js

@@ -0,0 +1,13 @@
+export default eventHandler(async (event) => {
+  const { model, id } = getRouterParams(event);
+  const table = getTableForModel(model);
+  const singularName = getModelSingularName(model);
+  const deletedRecord = await useDrizzle().delete(table).where(eq(table.id, Number(id))).returning().get();
+  if (!deletedRecord) {
+    throw createError({
+      statusCode: 404,
+      message: `${singularName} not found`
+    });
+  }
+  return deletedRecord;
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/[model]/[id].get.js

@@ -0,0 +1,13 @@
+export default eventHandler(async (event) => {
+  const { model, id } = getRouterParams(event);
+  const table = getTableForModel(model);
+  const singularName = getModelSingularName(model);
+  const record = await useDrizzle().select().from(table).where(eq(table.id, Number(id))).get();
+  if (!record) {
+    throw createError({
+      statusCode: 404,
+      message: `${singularName} not found`
+    });
+  }
+  return record;
+});

package/dist/runtime/server/api/[model]/[id].patch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/[model]/[id].patch.js

@@ -0,0 +1,8 @@
+export default eventHandler(async (event) => {
+  const { model, id } = getRouterParams(event);
+  const table = getTableForModel(model);
+  const body = await readBody(event);
+  const updateData = filterUpdatableFields(model, body);
+  const record = await useDrizzle().update(table).set(updateData).where(eq(table.id, Number(id))).returning().get();
+  return record;
+});

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

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/[model]/index.get.js

@@ -0,0 +1,6 @@
+export default eventHandler(async (event) => {
+  const { model } = getRouterParams(event);
+  const table = getTableForModel(model);
+  const records = await useDrizzle().select().from(table).all();
+  return records;
+});

package/dist/runtime/server/api/[model]/index.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/[model]/index.post.js

@@ -0,0 +1,11 @@
+export default eventHandler(async (event) => {
+  const { model } = getRouterParams(event);
+  const table = getTableForModel(model);
+  const body = await readBody(event);
+  const values = {
+    ...body,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+  const record = await useDrizzle().insert(table).values(values).returning().get();
+  return record;
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Custom updatable fields configuration (optional)
+ * Only define here if you want to override the auto-detection
+ *
+ * Example:
+ * export const customUpdatableFields: Record<string, string[]> = {
+ *   users: ['name', 'avatar'], // Only these fields can be updated
+ * }
+ */
+export declare const customUpdatableFields: Record<string, string[]>;
+/**
+ * Auto-generated model table map
+ * Automatically includes all tables from schema
+ */
+export declare const modelTableMap: Record<string, unknown>;
+/**
+ * Gets the table for a given model name
+ * @param modelName - The name of the model (e.g., 'users', 'products')
+ * @returns The corresponding database table
+ * @throws Error if model is not found
+ */
+export declare function getTableForModel(modelName: string): {};
+/**
+ * Gets the updatable fields for a model
+ * @param modelName - The name of the model
+ * @returns Array of field names that can be updated
+ */
+export declare function getUpdatableFields(modelName: string): string[];
+/**
+ * Filters an object to only include updatable fields for a model
+ * @param modelName - The name of the model
+ * @param data - The data object to filter
+ * @returns Filtered object with only updatable fields
+ */
+export declare function filterUpdatableFields(modelName: string, data: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Gets the singular name for a model (for error messages)
+ * Uses pluralize library for accurate singular/plural conversion
+ * @param modelName - The plural model name
+ * @returns The singular name in PascalCase
+ */
+export declare function getModelSingularName(modelName: string): string;
+/**
+ * Gets the plural name for a model
+ * @param modelName - The model name (singular or plural)
+ * @returns The plural name
+ */
+export declare function getModelPluralName(modelName: string): string;
+/**
+ * Lists all available models
+ * @returns Array of model names
+ */
+export declare function getAvailableModels(): string[];

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

@@ -0,0 +1,74 @@
+import * as schema from "#site/schema";
+import pluralize from "pluralize";
+import { pascalCase } from "scule";
+import { getTableColumns as getDrizzleTableColumns } from "drizzle-orm";
+import { createError } from "h3";
+const PROTECTED_FIELDS = ["id", "createdAt", "created_at"];
+export const customUpdatableFields = {
+  // Add custom field restrictions here if needed
+  // By default, all fields except PROTECTED_FIELDS are updatable
+};
+function buildModelTableMap() {
+  const tableMap = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (value && typeof value === "object") {
+      const hasTableSymbol = Symbol.for("drizzle:Name") in value;
+      const hasUnderscore = "_" in value;
+      const hasTableConfig = "table" in value || "$inferSelect" in value;
+      if (hasTableSymbol || hasUnderscore || hasTableConfig) {
+        tableMap[key] = value;
+      }
+    }
+  }
+  return tableMap;
+}
+export const modelTableMap = buildModelTableMap();
+export function getTableForModel(modelName) {
+  const table = modelTableMap[modelName];
+  if (!table) {
+    const availableModels = Object.keys(modelTableMap).join(", ");
+    throw createError({
+      statusCode: 404,
+      message: `Model '${modelName}' not found. Available models: ${availableModels}`
+    });
+  }
+  return table;
+}
+function getTableColumns(table) {
+  try {
+    const columns = getDrizzleTableColumns(table);
+    return Object.keys(columns);
+  } catch (e) {
+    console.error("[getTableColumns] Error getting columns:", e);
+    return [];
+  }
+}
+export function getUpdatableFields(modelName) {
+  if (customUpdatableFields[modelName]) {
+    return customUpdatableFields[modelName];
+  }
+  const table = modelTableMap[modelName];
+  if (!table) return [];
+  const allColumns = getTableColumns(table);
+  return allColumns.filter((col) => !PROTECTED_FIELDS.includes(col));
+}
+export function filterUpdatableFields(modelName, data) {
+  const allowedFields = getUpdatableFields(modelName);
+  const filtered = {};
+  for (const field of allowedFields) {
+    if (data[field] !== void 0) {
+      filtered[field] = data[field];
+    }
+  }
+  return filtered;
+}
+export function getModelSingularName(modelName) {
+  const singular = pluralize.singular(modelName);
+  return pascalCase(singular);
+}
+export function getModelPluralName(modelName) {
+  return pluralize.plural(modelName);
+}
+export function getAvailableModels() {
+  return Object.keys(modelTableMap);
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "nuxt-auto-crud",
+  "version": "1.1.0",
+  "description": "Exposes RESTful CRUD APIs for your Nuxt app based solely on your database migrations.",
+  "author": "Cliford Pereira",
+  "license": "MIT",
+  "keywords": [
+    "nuxt",
+    "nuxt-module",
+    "crud",
+    "auto-crud"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clifordpereira/nuxt-auto-crud"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "src/runtime"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+    "link": "npm link"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.2.1",
+    "@types/pluralize": "^0.0.33"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "^0.30.0",
+    "pluralize": "^8.0.0",
+    "scule": "^1.0.0"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.1.0",
+    "@nuxt/eslint-config": "^1.10.0",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.2.1",
+    "@nuxt/test-utils": "^3.20.1",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.1",
+    "nuxt": "^4.2.1",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.13",
+    "vue-tsc": "^3.1.5"
+  }
+}

package/src/runtime/server/api/[model]/[id].delete.ts

@@ -0,0 +1,21 @@
+// server/api/[model]/[id].delete.ts
+export default eventHandler(async (event) => {
+  const { model, id } = getRouterParams(event)
+  const table = getTableForModel(model)
+  const singularName = getModelSingularName(model)
+
+  const deletedRecord = await useDrizzle()
+    .delete(table)
+    .where(eq(table.id, Number(id)))
+    .returning()
+    .get()
+
+  if (!deletedRecord) {
+    throw createError({
+      statusCode: 404,
+      message: `${singularName} not found`,
+    })
+  }
+
+  return deletedRecord
+})

package/src/runtime/server/api/[model]/[id].get.ts

@@ -0,0 +1,21 @@
+// server/api/[model]/[id].get.ts
+export default eventHandler(async (event) => {
+  const { model, id } = getRouterParams(event)
+  const table = getTableForModel(model)
+  const singularName = getModelSingularName(model)
+
+  const record = await useDrizzle()
+    .select()
+    .from(table)
+    .where(eq(table.id, Number(id)))
+    .get()
+
+  if (!record) {
+    throw createError({
+      statusCode: 404,
+      message: `${singularName} not found`,
+    })
+  }
+
+  return record
+})

package/src/runtime/server/api/[model]/[id].patch.ts

@@ -0,0 +1,18 @@
+// server/api/[model]/[id].patch.ts
+export default eventHandler(async (event) => {
+  const { model, id } = getRouterParams(event)
+  const table = getTableForModel(model)
+  const body = await readBody(event)
+
+  // Filter to only allow updatable fields for this model
+  const updateData = filterUpdatableFields(model, body)
+
+  const record = await useDrizzle()
+    .update(table)
+    .set(updateData)
+    .where(eq(table.id, Number(id)))
+    .returning()
+    .get()
+
+  return record
+})

package/src/runtime/server/api/[model]/index.get.ts

@@ -0,0 +1,9 @@
+// server/api/[model]/index.get.ts
+export default eventHandler(async (event) => {
+  const { model } = getRouterParams(event)
+  const table = getTableForModel(model)
+
+  const records = await useDrizzle().select().from(table).all()
+
+  return records
+})

package/src/runtime/server/api/[model]/index.post.ts

@@ -0,0 +1,20 @@
+// server/api/[model]/index.post.ts
+export default eventHandler(async (event) => {
+  const { model } = getRouterParams(event)
+  const table = getTableForModel(model)
+  const body = await readBody(event)
+
+  // Add createdAt timestamp
+  const values = {
+    ...body,
+    createdAt: new Date(),
+  }
+
+  const record = await useDrizzle()
+    .insert(table)
+    .values(values)
+    .returning()
+    .get()
+
+  return record
+})

package/src/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/src/runtime/server/utils/modelMapper.ts

@@ -0,0 +1,163 @@
+// runtime/server/utils/modelMapper.ts
+// @ts-expect-error - #site/schema is an alias defined by the module
+import * as schema from '#site/schema'
+import pluralize from 'pluralize'
+import { pascalCase } from 'scule'
+import { getTableColumns as getDrizzleTableColumns } from 'drizzle-orm'
+import { createError } from 'h3'
+
+/**
+ * Fields that should never be updatable via PATCH requests
+ */
+const PROTECTED_FIELDS = ['id', 'createdAt', 'created_at']
+
+/**
+ * Custom updatable fields configuration (optional)
+ * Only define here if you want to override the auto-detection
+ *
+ * Example:
+ * export const customUpdatableFields: Record<string, string[]> = {
+ *   users: ['name', 'avatar'], // Only these fields can be updated
+ * }
+ */
+export const customUpdatableFields: Record<string, string[]> = {
+  // Add custom field restrictions here if needed
+  // By default, all fields except PROTECTED_FIELDS are updatable
+}
+
+/**
+ * Automatically builds a map of all exported tables from the schema
+ * No manual configuration needed!
+ */
+function buildModelTableMap(): Record<string, unknown> {
+  const tableMap: Record<string, unknown> = {}
+
+  // Iterate through all exports from schema
+  for (const [key, value] of Object.entries(schema)) {
+    // Check if it's a Drizzle table
+    // Drizzle tables have specific properties we can check
+    if (value && typeof value === 'object') {
+      // Check for common Drizzle table properties
+      const hasTableSymbol = Symbol.for('drizzle:Name') in value
+      const hasUnderscore = '_' in value
+      const hasTableConfig = 'table' in value || '$inferSelect' in value
+
+      if (hasTableSymbol || hasUnderscore || hasTableConfig) {
+        tableMap[key] = value
+      }
+    }
+  }
+
+  return tableMap
+}
+
+/**
+ * Auto-generated model table map
+ * Automatically includes all tables from schema
+ */
+export const modelTableMap = buildModelTableMap()
+
+/**
+ * Gets the table for a given model name
+ * @param modelName - The name of the model (e.g., 'users', 'products')
+ * @returns The corresponding database table
+ * @throws Error if model is not found
+ */
+export function getTableForModel(modelName: string) {
+  const table = modelTableMap[modelName]
+
+  if (!table) {
+    const availableModels = Object.keys(modelTableMap).join(', ')
+    throw createError({
+      statusCode: 404,
+      message: `Model '${modelName}' not found. Available models: ${availableModels}`,
+    })
+  }
+
+  return table
+}
+
+/**
+ * Auto-detects updatable fields for a table
+ * Returns all fields except protected ones (id, createdAt, etc.)
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getTableColumns(table: any): string[] {
+  try {
+    const columns = getDrizzleTableColumns(table)
+    return Object.keys(columns)
+  }
+  catch (e) {
+    console.error('[getTableColumns] Error getting columns:', e)
+    return []
+  }
+}
+
+/**
+ * Gets the updatable fields for a model
+ * @param modelName - The name of the model
+ * @returns Array of field names that can be updated
+ */
+export function getUpdatableFields(modelName: string): string[] {
+  // Check if custom fields are defined for this model
+  if (customUpdatableFields[modelName]) {
+    return customUpdatableFields[modelName]
+  }
+
+  // Auto-detect from table schema
+  const table = modelTableMap[modelName]
+
+  if (!table) return []
+
+  const allColumns = getTableColumns(table)
+
+  // Filter out protected fields
+  return allColumns.filter(col => !PROTECTED_FIELDS.includes(col))
+}
+
+/**
+ * Filters an object to only include updatable fields for a model
+ * @param modelName - The name of the model
+ * @param data - The data object to filter
+ * @returns Filtered object with only updatable fields
+ */
+export function filterUpdatableFields(modelName: string, data: Record<string, unknown>): Record<string, unknown> {
+  const allowedFields = getUpdatableFields(modelName)
+  const filtered: Record<string, unknown> = {}
+
+  for (const field of allowedFields) {
+    if (data[field] !== undefined) {
+      filtered[field] = data[field]
+    }
+  }
+
+  return filtered
+}
+
+/**
+ * Gets the singular name for a model (for error messages)
+ * Uses pluralize library for accurate singular/plural conversion
+ * @param modelName - The plural model name
+ * @returns The singular name in PascalCase
+ */
+export function getModelSingularName(modelName: string): string {
+  const singular = pluralize.singular(modelName)
+  return pascalCase(singular)
+}
+
+/**
+ * Gets the plural name for a model
+ * @param modelName - The model name (singular or plural)
+ * @returns The plural name
+ */
+export function getModelPluralName(modelName: string): string {
+  return pluralize.plural(modelName)
+}
+
+/**
+ * Lists all available models
+ * @returns Array of model names
+ */
+export function getAvailableModels(): string[] {
+  return Object.keys(modelTableMap)
+}