@zenith-open/zenithcms-db-mongodb 0.1.0 → 1.0.0-beta.1

package/src/model-factory.ts

@@ -1,179 +0,0 @@
-import mongoose, { Schema, Model } from 'mongoose'
-import { CollectionConfig, FieldConfig } from '@zenith-open/zenithcms-types'
-
-const models: Record<string, Model<unknown>> = {}
-
-function mapFieldToMongoose(field: any): unknown {
-  let type: unknown
-
-  switch (field.type) {
-    case 'text':
-    case 'email':
-    case 'textarea':
-    case 'select':
-      type = String
-      break
-    case 'richtext':
-      type = field.format === 'json' ? Schema.Types.Mixed : String
-      break
-    case 'number':
-      type = Number
-      break
-    case 'boolean':
-    case 'checkbox':
-      type = Boolean
-      break
-    case 'date':
-      type = Date
-      break
-    case 'json':
-      type = Schema.Types.Mixed
-      break
-    case 'media':
-      type = new Schema(
-        {
-          url: String,
-          id: String,
-          alt: String,
-          width: Number,
-          height: Number,
-        },
-        { _id: false }
-      )
-      break
-    case 'relation':
-      // Use String instead of ObjectId to support database-agnostic string IDs and UUIDs
-      type = String
-      break
-    case 'array':
-      if (field.fields) {
-        type = [new Schema(generateSchemaFields(field.fields), { _id: false })]
-      } else {
-        type = [Schema.Types.Mixed]
-      }
-      break
-    case 'group':
-      if (field.fields) {
-        type = new Schema(generateSchemaFields(field.fields), { _id: false })
-      } else {
-        type = Schema.Types.Mixed
-      }
-      break
-    case 'blocks':
-      if (field.blocks && field.blocks.length > 0) {
-        // Blocks are stored as objects with a blockType discriminator
-        type = [
-          new Schema(
-            {
-              blockType: { type: String, index: true },
-            },
-            { strict: false, _id: false }
-          ),
-        ]
-      } else {
-        type = [Schema.Types.Mixed]
-      }
-      break
-    case 'code':
-    case 'radio':
-      type = String
-      break
-    case 'collapsible':
-      if (field.fields) {
-        type = new Schema(generateSchemaFields(field.fields), { _id: false })
-      } else {
-        type = Schema.Types.Mixed
-      }
-      break
-    case 'join':
-      // Virtual read-only field — stored as array of Mixed
-      type = [Schema.Types.Mixed]
-      break
-    case 'point':
-      // Stored as [lng, lat] tuple
-      type = [Number]
-      break
-    case 'row':
-    case 'ui':
-      // Layout/presentational fields — no data stored
-      return undefined as any
-    default:
-      type = Schema.Types.Mixed
-  }
-
-  if (field.hasMany && field.type !== 'array') {
-    type = [type]
-  }
-
-  // Handle i18n
-  if (field.localized) {
-    type = new Schema(
-      {
-        // We use a Mixed object to store any locale keys (en, es, fr, etc.)
-      },
-      { strict: false, _id: false }
-    )
-  }
-
-  const mongooseField: any = {
-    type,
-    required: field.required || false,
-    default: field.defaultValue,
-  }
-  
-  if (field.unique !== undefined) mongooseField.unique = field.unique;
-  if (field.index !== undefined) mongooseField.index = field.index;
-  
-  return mongooseField;
-}
-
-function generateSchemaFields(fields: FieldConfig[]) {
-  const schemaFields: Record<string, unknown> = {}
-  fields.forEach((field) => {
-    // Skip layout/presentational fields that produce no schema mapping
-    if (field.type === 'row' || field.type === 'ui') return
-    schemaFields[field.name] = mapFieldToMongoose(field)
-  })
-  return schemaFields
-}
-
-export function getModelForCollection(config: CollectionConfig): Model<unknown> {
-  if (models[config.slug]) return models[config.slug]
-
-  const schemaFields = generateSchemaFields(config.fields)
-
-  const schema = new Schema(schemaFields, {
-    timestamps: config.timestamps !== false,
-    collection: config.slug,
-    strict: false, // Allow extra dynamic fields
-  })
-
-  // Global meta fields
-  schema.add({
-    siteId: { type: String, index: true },
-    isFocused: { type: Boolean, default: false },
-    _status: {
-      type: String,
-      enum: ['draft', 'published'],
-      default: config.drafts ? 'draft' : 'published',
-    },
-  })
-
-  // Scheduling support
-  if (config.scheduling) {
-    schema.add({
-      scheduledAt: { type: Date, index: true },
-    })
-  }
-
-  // Soft Delete support
-  if (config.softDelete) {
-    schema.add({
-      deletedAt: { type: Date, default: null, index: true },
-    })
-  }
-
-  const model = mongoose.models[config.slug] || mongoose.model(config.slug, schema)
-  models[config.slug] = model
-  return model
-}

package/tsconfig.eslint.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "allowJs": true
-  },
-  "include": ["src/**/*", "tests/**/*", "bin/**/*", "*.ts", "*.mjs"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "paths": {}
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}