nuxt-auto-crud 1.4.0 → 1.6.0

package/dist/runtime/server/api/_schema/[table].get.js

@@ -0,0 +1,32 @@
+import { eventHandler, createError, getRouterParam } from "h3";
+import { getSchema } from "../../utils/schema.js";
+import { useAutoCrudConfig } from "../../utils/config.js";
+import { verifyJwtToken } from "../../utils/jwt.js";
+export default eventHandler(async (event) => {
+  const { auth } = useAutoCrudConfig();
+  const tableName = getRouterParam(event, "table");
+  if (auth?.authentication) {
+    let isAuthenticated = false;
+    if (auth.type === "jwt" && auth.jwtSecret) {
+      isAuthenticated = await verifyJwtToken(event, auth.jwtSecret);
+    } else {
+      try {
+        await requireUserSession(event);
+        isAuthenticated = true;
+      } catch {
+        isAuthenticated = false;
+      }
+    }
+    if (!isAuthenticated) {
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
+  }
+  if (!tableName) {
+    throw createError({ statusCode: 400, message: "Table name is required" });
+  }
+  const schema = await getSchema(tableName);
+  if (!schema) {
+    throw createError({ statusCode: 404, message: `Table '${tableName}' not found` });
+  }
+  return schema;
+});

package/dist/runtime/server/api/_schema/index.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Record<string, any>>>;
+export default _default;

package/dist/runtime/server/api/_schema/index.get.js

@@ -0,0 +1,24 @@
+import { eventHandler, createError } from "h3";
+import { getAllSchemas } from "../../utils/schema.js";
+import { useAutoCrudConfig } from "../../utils/config.js";
+import { verifyJwtToken } from "../../utils/jwt.js";
+export default eventHandler(async (event) => {
+  const { auth } = useAutoCrudConfig();
+  if (auth?.authentication) {
+    let isAuthenticated = false;
+    if (auth.type === "jwt" && auth.jwtSecret) {
+      isAuthenticated = await verifyJwtToken(event, auth.jwtSecret);
+    } else {
+      try {
+        await requireUserSession(event);
+        isAuthenticated = true;
+      } catch {
+        isAuthenticated = false;
+      }
+    }
+    if (!isAuthenticated) {
+      throw createError({ statusCode: 401, message: "Unauthorized" });
+    }
+  }
+  return getAllSchemas();
+});

package/dist/runtime/server/plugins/seed.d.ts

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

package/dist/runtime/server/plugins/seed.js

@@ -0,0 +1,36 @@
+import { eq } from "drizzle-orm";
+import { useDrizzle } from "#site/drizzle";
+import * as tables from "#site/schema";
+import { useAutoCrudConfig } from "../utils/config.js";
+import { defineNitroPlugin } from "#imports";
+export default defineNitroPlugin(async () => {
+  if (typeof onHubReady === "function") {
+    onHubReady(async () => {
+      const { auth } = useAutoCrudConfig();
+      if (!auth?.authentication || !tables.users) {
+        return;
+      }
+      const db = useDrizzle();
+      const existingAdmin = await db.select().from(tables.users).where(eq(tables.users.email, "admin@example.com")).get();
+      if (!existingAdmin) {
+        console.log("Seeding admin user...");
+        let hashedPassword = "$1Password";
+        try {
+          hashedPassword = await hashPassword("$1Password");
+        } catch {
+          console.warn("hashPassword not available, using plain text (insecure)");
+        }
+        await db.insert(tables.users).values({
+          email: "admin@example.com",
+          password: hashedPassword,
+          name: "Admin User",
+          avatar: "https://i.pravatar.cc/150?u=admin",
+          role: "admin",
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+        console.log("Admin user seeded.");
+      }
+    });
+  }
+});

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

@@ -3,7 +3,7 @@ import { useAutoCrudConfig } from "./config.js";
 import { verifyJwtToken } from "./jwt.js";
 export async function checkAdminAccess(event, model, action) {
   const { auth } = useAutoCrudConfig();
-  if (!auth?.enabled) {
+  if (!auth?.authentication) {
     return true;
   }
   if (auth.type === "jwt") {

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

@@ -1,2 +1,2 @@
-import type { ModuleOptions } from '../../../types.js';
-export declare const useAutoCrudConfig: () => ModuleOptions;
+import type { RuntimeModuleOptions } from '../../../types.js';
+export declare const useAutoCrudConfig: () => RuntimeModuleOptions;

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

@@ -1,10 +1,10 @@
 import * as schema from "#site/schema";
 import pluralize from "pluralize";
 import { pascalCase } from "scule";
-import { getTableColumns as getDrizzleTableColumns } from "drizzle-orm";
+import { getTableColumns as getDrizzleTableColumns, getTableName } from "drizzle-orm";
 import { createError } from "h3";
 import { useRuntimeConfig } from "#imports";
-const PROTECTED_FIELDS = ["id", "createdAt", "created_at"];
+const PROTECTED_FIELDS = ["id", "created_at", "updated_at", "createdAt", "updatedAt"];
 const HIDDEN_FIELDS = ["password", "secret", "token"];
 export const customUpdatableFields = {
   // Add custom field restrictions here if needed
@@ -17,11 +17,12 @@ 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;
+      try {
+        const tableName = getTableName(value);
+        if (tableName) {
+          tableMap[key] = value;
+        }
+      } catch {
       }
     }
   }
@@ -60,9 +61,16 @@ export function getUpdatableFields(modelName) {
 export function filterUpdatableFields(modelName, data) {
   const allowedFields = getUpdatableFields(modelName);
   const filtered = {};
+  const table = modelTableMap[modelName];
+  const columns = table ? getDrizzleTableColumns(table) : {};
   for (const field of allowedFields) {
     if (data[field] !== void 0) {
-      filtered[field] = data[field];
+      let value = data[field];
+      const column = columns[field];
+      if (column && column.mode === "timestamp" && typeof value === "string") {
+        value = new Date(value);
+      }
+      filtered[field] = value;
     }
   }
   return filtered;

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

@@ -0,0 +1,20 @@
+export declare function drizzleTableToFields(table: any, resourceName: string): {
+    resource: string;
+    fields: {
+        name: string;
+        type: string;
+        required: any;
+        selectOptions: undefined;
+    }[];
+};
+export declare function getRelations(): Promise<Record<string, Record<string, string>>>;
+export declare function getAllSchemas(): Promise<Record<string, any>>;
+export declare function getSchema(tableName: string): Promise<{
+    resource: string;
+    fields: {
+        name: string;
+        type: string;
+        required: any;
+        selectOptions: undefined;
+    }[];
+} | undefined>;

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

@@ -0,0 +1,70 @@
+import { getTableColumns } from "drizzle-orm";
+import { getTableConfig } from "drizzle-orm/sqlite-core";
+import { modelTableMap } from "./modelMapper.js";
+export function drizzleTableToFields(table, resourceName) {
+  const columns = getTableColumns(table);
+  const fields = [];
+  for (const [key, col] of Object.entries(columns)) {
+    const column = col;
+    const isRequired = column.notNull;
+    let type = "string";
+    const selectOptions = void 0;
+    if (column.dataType === "number" || column.columnType === "SQLiteInteger" || column.columnType === "SQLiteReal") {
+      type = "number";
+      if (column.name.endsWith("_at") || column.name.endsWith("At")) {
+        type = "date";
+      }
+    } else if (column.dataType === "boolean") {
+      type = "boolean";
+    } else if (column.dataType === "date" || column.dataType === "string" && (column.name.endsWith("_at") || column.name.endsWith("At"))) {
+      type = "date";
+    }
+    fields.push({
+      name: key,
+      type,
+      required: isRequired,
+      selectOptions
+    });
+  }
+  return {
+    resource: resourceName,
+    fields
+  };
+}
+export async function getRelations() {
+  const relations = {};
+  for (const [tableName, table] of Object.entries(modelTableMap)) {
+    try {
+      const config = getTableConfig(table);
+      if (config.foreignKeys.length > 0) {
+        const tableRelations = {};
+        relations[tableName] = tableRelations;
+        const columns = getTableColumns(table);
+        const columnToProperty = {};
+        for (const [key, col] of Object.entries(columns)) {
+          columnToProperty[col.name] = key;
+        }
+        config.foreignKeys.forEach((fk) => {
+          const sourceColumnName = fk.reference().columns[0].name;
+          const sourceProperty = columnToProperty[sourceColumnName] || sourceColumnName;
+          const targetTable = fk.reference().foreignTable[Symbol.for("drizzle:Name")];
+          tableRelations[sourceProperty] = targetTable;
+        });
+      }
+    } catch {
+    }
+  }
+  return relations;
+}
+export async function getAllSchemas() {
+  const schemas = {};
+  for (const [tableName, table] of Object.entries(modelTableMap)) {
+    schemas[tableName] = drizzleTableToFields(table, tableName);
+  }
+  return schemas;
+}
+export async function getSchema(tableName) {
+  const table = modelTableMap[tableName];
+  if (!table) return void 0;
+  return drizzleTableToFields(table, tableName);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-auto-crud",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Exposes RESTful CRUD APIs for your Nuxt app based solely on your database migrations.",
   "author": "Cliford Pereira",
   "license": "MIT",
@@ -35,15 +35,15 @@
   ],
   "scripts": {
     "prepack": "nuxt-module-build build",
-    "dev": "npm run dev:prepare && nuxi dev playground-fullstack",
-    "dev:build": "nuxi build playground-fullstack",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground-fullstack",
+    "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:api": "node scripts/test-api.mjs",
     "test:watch": "vitest watch",
-    "test:types": "vue-tsc --noEmit && cd playground-fullstack && vue-tsc --noEmit",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "link": "npm link"
   },
   "dependencies": {
@@ -58,6 +58,9 @@
     "drizzle-orm": "^0.30.0"
   },
   "devDependencies": {
+    "@iconify-json/heroicons": "^1.2.3",
+    "@iconify-json/lucide": "^1.2.77",
+    "@iconify-json/simple-icons": "^1.2.61",
     "@nuxt/devtools": "^3.1.0",
     "@nuxt/eslint-config": "^1.10.0",
     "@nuxt/module-builder": "^1.0.2",

package/src/runtime/composables/useRelationDisplay.ts

@@ -0,0 +1,67 @@
+import { ref, useFetch, useRequestHeaders } from '#imports'
+
+export const useRelationDisplay = (
+  schema: {
+    resource: string
+    fields: { name: string, type: string, required?: boolean }[]
+  },
+) => {
+  const resourceName = schema.resource
+  const relationsMap = ref<Record<string, Record<string, string>>>({})
+  const displayValues = ref<Record<string, Record<string, string>>>({})
+  const headers = useRequestHeaders(['cookie'])
+
+  const fetchRelations = async () => {
+    // 1. Fetch relations metadata
+    const { data: relations } = await useFetch<Record<string, Record<string, string>>>('/api/_relations')
+    if (relations.value) {
+      relationsMap.value = relations.value
+    }
+
+    // 2. Identify relation fields for this resource
+    const resourceRelations = relationsMap.value[resourceName] || {}
+    const relationFields = Object.keys(resourceRelations)
+
+    if (relationFields.length === 0) return
+
+    // 3. Fetch data for each relation
+    await Promise.all(
+      relationFields.map(async (fieldName) => {
+        const targetTable = resourceRelations[fieldName]
+        // We assume the API for targetTable is /api/[targetTable]
+        try {
+          const relatedData = await $fetch<Record<string, unknown>[]>(`/api/${targetTable}`, { headers })
+
+          if (relatedData) {
+            displayValues.value[fieldName] = relatedData.reduce<Record<string, string>>(
+              (acc, item) => {
+                const id = item.id as number
+                // Try to find a good display name
+                const label = (item.name || item.title || item.email || item.username || `#${item.id}`) as string
+                acc[id] = label
+                return acc
+              },
+              {},
+            )
+          }
+        }
+        catch (error) {
+          console.error(`Failed to fetch relation data for ${targetTable}:`, error)
+        }
+      }),
+    )
+  }
+
+  const getDisplayValue = (key: string, value: unknown) => {
+    if (displayValues.value[key] && (typeof value === 'number' || typeof value === 'string')) {
+      return displayValues.value[key][value as string] || value
+    }
+    return value
+  }
+
+  return {
+    fetchRelations,
+    getDisplayValue,
+    relationsMap,
+  }
+}

package/src/runtime/composables/useResourceSchemas.ts

@@ -0,0 +1,42 @@
+import { useAsyncData, useRequestHeaders } from '#imports'
+import type { Ref } from 'vue'
+
+export interface ResourceField {
+  name: string
+  type: string
+  required?: boolean
+  selectOptions?: string[]
+}
+
+export interface ResourceSchema {
+  resource: string
+  fields: ResourceField[]
+}
+
+export type ResourceSchemas = Record<string, ResourceSchema>
+
+export const useResourceSchemas = async (): Promise<{
+  schemas: Ref<ResourceSchemas | null | undefined>
+  getSchema: (resource: string) => ResourceSchema | undefined
+  status: Ref<'idle' | 'pending' | 'success' | 'error'>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error: Ref<any>
+  refresh: () => Promise<void>
+}> => {
+  const { data: schemas, status, error, refresh } = await useAsyncData<ResourceSchemas>('resource-schemas', () => $fetch('/api/_schema', {
+    headers: useRequestHeaders(['cookie']),
+  }))
+
+  const getSchema = (resource: string) => {
+    if (!schemas.value) return undefined
+    return schemas.value[resource]
+  }
+
+  return {
+    schemas,
+    getSchema,
+    status,
+    error,
+    refresh: refresh as unknown as () => Promise<void>,
+  }
+}

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

@@ -34,6 +34,11 @@ export default eventHandler(async (event) => {
   const body = await readBody(event)
   const payload = filterUpdatableFields(model, body)
 
+  // Automatically update updatedAt if it exists
+  if ('updatedAt' in table) {
+    payload.updatedAt = new Date()
+  }
+
   const updatedRecord = await useDrizzle()
     .update(table)
     .set(payload)

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

@@ -8,6 +8,9 @@ import { useDrizzle } from '#site/drizzle'
 import { useAutoCrudConfig } from '../../utils/config'
 import { checkAdminAccess } from '../../utils/auth'
 
+import { desc } from 'drizzle-orm'
+import type { TableWithId } from '../../types'
+
 export default eventHandler(async (event) => {
   console.log('[GET] Request received', event.path)
   const { resources } = useAutoCrudConfig()
@@ -28,9 +31,9 @@ export default eventHandler(async (event) => {
     }
   }
 
-  const table = getTableForModel(model)
+  const table = getTableForModel(model) as TableWithId
 
-  const results = await useDrizzle().select().from(table).all()
+  const results = await useDrizzle().select().from(table).orderBy(desc(table.id)).all()
 
   return results.map((item: Record<string, unknown>) => {
     if (isAdmin) {

package/src/runtime/server/api/_relations.get.ts

@@ -0,0 +1,31 @@
+import { eventHandler, createError } from 'h3'
+import { getRelations } from '../utils/schema'
+import { useAutoCrudConfig } from '../utils/config'
+import { verifyJwtToken } from '../utils/jwt'
+
+export default eventHandler(async (event) => {
+  const { auth } = useAutoCrudConfig()
+
+  if (auth?.authentication) {
+    let isAuthenticated = false
+    if (auth.type === 'jwt' && auth.jwtSecret) {
+      isAuthenticated = await verifyJwtToken(event, auth.jwtSecret)
+    }
+    else {
+      try {
+        // @ts-expect-error - requireUserSession is auto-imported
+        await requireUserSession(event)
+        isAuthenticated = true
+      }
+      catch {
+        isAuthenticated = false
+      }
+    }
+
+    if (!isAuthenticated) {
+      throw createError({ statusCode: 401, message: 'Unauthorized' })
+    }
+  }
+
+  return getRelations()
+})

package/src/runtime/server/api/_schema/[table].get.ts

@@ -0,0 +1,41 @@
+import { eventHandler, createError, getRouterParam } from 'h3'
+import { getSchema } from '../../utils/schema'
+import { useAutoCrudConfig } from '../../utils/config'
+import { verifyJwtToken } from '../../utils/jwt'
+
+export default eventHandler(async (event) => {
+  const { auth } = useAutoCrudConfig()
+  const tableName = getRouterParam(event, 'table')
+
+  if (auth?.authentication) {
+    let isAuthenticated = false
+    if (auth.type === 'jwt' && auth.jwtSecret) {
+      isAuthenticated = await verifyJwtToken(event, auth.jwtSecret)
+    }
+    else {
+      try {
+        // @ts-expect-error - requireUserSession is auto-imported
+        await requireUserSession(event)
+        isAuthenticated = true
+      }
+      catch {
+        isAuthenticated = false
+      }
+    }
+
+    if (!isAuthenticated) {
+      throw createError({ statusCode: 401, message: 'Unauthorized' })
+    }
+  }
+
+  if (!tableName) {
+    throw createError({ statusCode: 400, message: 'Table name is required' })
+  }
+
+  const schema = await getSchema(tableName)
+  if (!schema) {
+    throw createError({ statusCode: 404, message: `Table '${tableName}' not found` })
+  }
+
+  return schema
+})

package/src/runtime/server/api/_schema/index.get.ts

@@ -0,0 +1,31 @@
+import { eventHandler, createError } from 'h3'
+import { getAllSchemas } from '../../utils/schema'
+import { useAutoCrudConfig } from '../../utils/config'
+import { verifyJwtToken } from '../../utils/jwt'
+
+export default eventHandler(async (event) => {
+  const { auth } = useAutoCrudConfig()
+
+  if (auth?.authentication) {
+    let isAuthenticated = false
+    if (auth.type === 'jwt' && auth.jwtSecret) {
+      isAuthenticated = await verifyJwtToken(event, auth.jwtSecret)
+    }
+    else {
+      try {
+        // @ts-expect-error - requireUserSession is auto-imported
+        await requireUserSession(event)
+        isAuthenticated = true
+      }
+      catch {
+        isAuthenticated = false
+      }
+    }
+
+    if (!isAuthenticated) {
+      throw createError({ statusCode: 401, message: 'Unauthorized' })
+    }
+  }
+
+  return getAllSchemas()
+})

package/src/runtime/server/plugins/seed.ts

@@ -0,0 +1,55 @@
+import { eq } from 'drizzle-orm'
+// @ts-expect-error - #site/drizzle is an alias defined by the module
+import { useDrizzle } from '#site/drizzle'
+// @ts-expect-error - #site/schema is an alias defined by the module
+import * as tables from '#site/schema'
+import { useAutoCrudConfig } from '../utils/config'
+// @ts-expect-error - #imports is available in runtime
+import { defineNitroPlugin } from '#imports'
+
+export default defineNitroPlugin(async () => {
+  // @ts-expect-error - onHubReady is auto-imported from @nuxthub/core
+  if (typeof onHubReady === 'function') {
+    // @ts-expect-error - onHubReady is auto-imported from @nuxthub/core
+    onHubReady(async () => {
+      const { auth } = useAutoCrudConfig()
+
+      // Only seed if auth is enabled and we have a users table
+      if (!auth?.authentication || !tables.users) {
+        return
+      }
+
+      const db = useDrizzle()
+
+      // Check if admin exists
+      const existingAdmin = await db.select().from(tables.users).where(eq(tables.users.email, 'admin@example.com')).get()
+
+      if (!existingAdmin) {
+        console.log('Seeding admin user...')
+        // Use hashPassword from nuxt-auth-utils if available, otherwise simple mock or error
+        // Since we can't guarantee nuxt-auth-utils is present in module context, we try to use it dynamically or assume it's there
+        // But wait, the module depends on nuxt-auth-utils being present in the user project for auth to work.
+
+        let hashedPassword = '$1Password'
+        try {
+          // @ts-expect-error - hashPassword is auto-imported
+          hashedPassword = await hashPassword('$1Password')
+        }
+        catch {
+          console.warn('hashPassword not available, using plain text (insecure)')
+        }
+
+        await db.insert(tables.users).values({
+          email: 'admin@example.com',
+          password: hashedPassword,
+          name: 'Admin User',
+          avatar: 'https://i.pravatar.cc/150?u=admin',
+          role: 'admin',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        })
+        console.log('Admin user seeded.')
+      }
+    })
+  }
+})

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

@@ -6,7 +6,7 @@ import { verifyJwtToken } from './jwt'
 export async function checkAdminAccess(event: H3Event, model: string, action: string): Promise<boolean> {
   const { auth } = useAutoCrudConfig()
 
-  if (!auth?.enabled) {
+  if (!auth?.authentication) {
     return true
   }
 

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

@@ -1,6 +1,6 @@
 import { useRuntimeConfig } from '#imports'
-import type { ModuleOptions } from '../../../types'
+import type { RuntimeModuleOptions } from '../../../types'
 
-export const useAutoCrudConfig = (): ModuleOptions => {
-  return useRuntimeConfig().autoCrud as ModuleOptions
+export const useAutoCrudConfig = (): RuntimeModuleOptions => {
+  return useRuntimeConfig().autoCrud as RuntimeModuleOptions
 }