nuxt-auto-crud 1.4.0 → 1.6.0

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

@@ -3,7 +3,7 @@
 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 type { SQLiteTable } from 'drizzle-orm/sqlite-core'
 import { createError } from 'h3'
 import { useRuntimeConfig } from '#imports'
@@ -11,7 +11,7 @@ import { useRuntimeConfig } from '#imports'
 /**
  * Fields that should never be updatable via PATCH requests
  */
-const PROTECTED_FIELDS = ['id', 'createdAt', 'created_at']
+const PROTECTED_FIELDS = ['id', 'created_at', 'updated_at', 'createdAt', 'updatedAt']
 
 /**
  * Fields that should never be returned in API responses
@@ -50,15 +50,18 @@ function buildModelTableMap(): 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
+      try {
+        // getTableName returns the table name for valid tables, and undefined/null for others (like relations)
+        // This is a more robust check than checking for properties
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tableName = getTableName(value as any)
+        if (tableName) {
+          tableMap[key] = value
+        }
+      }
+      catch {
+        // Ignore if it throws (not a table)
       }
     }
   }
@@ -139,10 +142,21 @@ export function getUpdatableFields(modelName: string): string[] {
 export function filterUpdatableFields(modelName: string, data: Record<string, unknown>): Record<string, unknown> {
   const allowedFields = getUpdatableFields(modelName)
   const filtered: Record<string, unknown> = {}
+  const table = modelTableMap[modelName]
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const columns = table ? getDrizzleTableColumns(table as any) : {}
 
   for (const field of allowedFields) {
     if (data[field] !== undefined) {
-      filtered[field] = data[field]
+      let value = data[field]
+      const column = columns[field]
+
+      // Coerce timestamp fields to Date objects if they are strings
+      if (column && column.mode === 'timestamp' && typeof value === 'string') {
+        value = new Date(value)
+      }
+
+      filtered[field] = value
     }
   }
 

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

@@ -0,0 +1,96 @@
+import { getTableColumns } from 'drizzle-orm'
+import { getTableConfig } from 'drizzle-orm/sqlite-core'
+import { modelTableMap } from './modelMapper'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function drizzleTableToFields(table: any, resourceName: string) {
+  const columns = getTableColumns(table)
+  const fields = []
+
+  for (const [key, col] of Object.entries(columns)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const column = col as any
+    const isRequired = column.notNull
+    let type = 'string'
+    const selectOptions: string[] | undefined = undefined
+
+    // Map Drizzle types to frontend types
+    if (column.dataType === 'number' || column.columnType === 'SQLiteInteger' || column.columnType === 'SQLiteReal') {
+      type = 'number'
+      // Check if it is a timestamp
+      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: Record<string, Record<string, string>> = {}
+
+  for (const [tableName, table] of Object.entries(modelTableMap)) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const config = getTableConfig(table as any)
+      if (config.foreignKeys.length > 0) {
+        const tableRelations: Record<string, string> = {}
+        relations[tableName] = tableRelations
+
+        // Map column names to property names
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const columns = getTableColumns(table as any)
+        const columnToProperty: Record<string, string> = {}
+        for (const [key, col] of Object.entries(columns)) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          columnToProperty[(col as any).name] = key
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        config.foreignKeys.forEach((fk: any) => {
+          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 {
+      // Ignore tables that don't have config (e.g. not Drizzle tables)
+    }
+  }
+  return relations
+}
+
+export async function getAllSchemas() {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const schemas: Record<string, any> = {}
+
+  for (const [tableName, table] of Object.entries(modelTableMap)) {
+    schemas[tableName] = drizzleTableToFields(table, tableName)
+  }
+  return schemas
+}
+
+export async function getSchema(tableName: string) {
+  const table = modelTableMap[tableName]
+  if (!table) return undefined
+  return drizzleTableToFields(table, tableName)
+}