opacacms 0.1.12 → 0.1.13

package/src/validation.ts

@@ -1,429 +0,0 @@
-import { z } from "zod";
-
-export const FieldTypeSchema = z.enum([
-  "text",
-  "slug",
-  "textarea",
-  "number",
-  "richtext",
-  "relationship",
-  "select",
-  "radio",
-  "date",
-  "boolean",
-  "json",
-  "file",
-  "blocks",
-  "group",
-  "row",
-  "collapsible",
-  "tabs",
-  "join",
-  "array",
-  "virtual",
-]);
-
-export type FieldType = z.infer<typeof FieldTypeSchema>;
-
-const BaseFieldSchema = z.object({
-  name: z.string(),
-  label: z.string().optional(),
-  required: z.boolean().optional().default(false),
-  unique: z.boolean().optional().default(false),
-  localized: z.boolean().optional(),
-  defaultValue: z.any().optional(),
-  validate: z.function().optional(),
-  admin: z
-    .object({
-      description: z.string().optional(),
-      condition: z.function().optional(),
-      hidden: z.boolean().optional(),
-      readOnly: z.boolean().optional(),
-      width: z.string().optional(),
-      style: z.any().optional(),
-      className: z.string().optional(),
-      components: z
-        .object({
-          Field: z.string().optional(),
-          Cell: z.string().optional(),
-        })
-        .optional(),
-    })
-    .optional(),
-});
-
-export const FieldSchema: z.ZodType<unknown> = z.lazy(() =>
-  z.discriminatedUnion("type", [
-    // Simple types
-    BaseFieldSchema.extend({ type: z.literal("text") }),
-    BaseFieldSchema.extend({
-      type: z.literal("slug"),
-      from: z.string(),
-      format: z.function().optional(),
-    }),
-    BaseFieldSchema.extend({ type: z.literal("textarea") }),
-    BaseFieldSchema.extend({ type: z.literal("number") }),
-    BaseFieldSchema.extend({ type: z.literal("date") }),
-    BaseFieldSchema.extend({
-      type: z.literal("boolean"),
-      options: z
-        .object({
-          display: z.enum(["switch", "toggle", "checkbox", "select"]).optional().default("switch"),
-        })
-        .loose()
-        .optional(),
-    }),
-
-    // Complex types
-    BaseFieldSchema.extend({
-      type: z.literal("richtext"),
-      options: z
-        .object({
-          defaultMode: z.enum(["simple", "notion"]).optional(),
-        })
-        .loose()
-        .optional(),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("relationship"),
-      relationTo: z.string(),
-      hasMany: z.boolean().optional(),
-      displayField: z.string().optional(),
-      references: z
-        .object({
-          table: z.string(),
-          column: z.string(),
-          onDelete: z.enum(["cascade", "set null", "restrict", "no action"]).optional(),
-        })
-        .optional(),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("select"),
-      options: z
-        .object({
-          choices: z.array(
-            z.union([z.string(), z.object({ label: z.string(), value: z.string() })]),
-          ),
-        })
-        .loose()
-        .optional(),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("radio"),
-      options: z
-        .object({
-          choices: z.array(
-            z.union([z.string(), z.object({ label: z.string(), value: z.string() })]),
-          ),
-        })
-        .loose(),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("file"),
-      bucket: z.string().optional(),
-      options: z
-        .object({
-          allowedmime_types: z.array(z.string()).optional(),
-          maxFileSize: z.number().optional(),
-          metaFields: z.array(z.lazy(() => FieldSchema)).optional(),
-        })
-        .loose()
-        .optional(),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("json"),
-      fields: z.array(z.lazy(() => FieldSchema)).optional(),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("blocks"),
-      blocks: z.array(
-        z.object({
-          slug: z.string(),
-          fields: z.array(z.lazy(() => FieldSchema)),
-          label: z.string().optional(),
-        }),
-      ),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("group"),
-      fields: z.array(z.lazy(() => FieldSchema)),
-    }),
-
-    // Layout Types
-    z.object({
-      name: z.string().optional(),
-      type: z.literal("row"),
-      fields: z.array(z.lazy(() => FieldSchema)),
-      label: z.string().optional(),
-    }),
-
-    z.object({
-      name: z.string().optional(),
-      type: z.literal("collapsible"),
-      fields: z.array(z.lazy(() => FieldSchema)),
-      label: z.string().optional(),
-      options: z
-        .object({
-          initiallyCollapsed: z.boolean().optional(),
-        })
-        .loose()
-        .optional(),
-    }),
-
-    z.object({
-      name: z.string().optional(),
-      type: z.literal("tabs"),
-      tabs: z.array(
-        z.object({
-          label: z.string(),
-          fields: z.array(z.lazy(() => FieldSchema)),
-        }),
-      ),
-    }),
-
-    // Virtual Types
-    z.object({
-      name: z
-        .string()
-        .optional()
-        .refine((val) => val === undefined, {
-          message:
-            "Join fields are virtual and should not have a 'name' property. They are mapped dynamically via the API.",
-        })
-        .or(z.string()),
-      type: z.literal("join"),
-      collection: z.string(),
-      on: z.string(),
-      label: z.string().optional(),
-    }),
-
-    BaseFieldSchema.extend({
-      type: z.literal("array"),
-      fields: z.array(z.lazy(() => FieldSchema)).optional(),
-    }),
-    BaseFieldSchema.extend({
-      type: z.literal("virtual"),
-      resolve: z.function(),
-      returnType: z.string().optional(),
-    }),
-  ]),
-);
-
-export type Field = z.infer<typeof FieldSchema>;
-
-export const AccessConfigSchema = z.object({
-  read: z.union([z.boolean(), z.function()]).optional(),
-  create: z.union([z.boolean(), z.function()]).optional(),
-  update: z.union([z.boolean(), z.function()]).optional(),
-  delete: z.union([z.boolean(), z.function()]).optional(),
-  requireApiKey: z.boolean().optional(),
-});
-
-export type AccessConfig = z.infer<typeof AccessConfigSchema>;
-
-export const CollectionHooksSchema = z.object({
-  beforeCreate: z.function().optional(),
-  afterCreate: z.function().optional(),
-  beforeUpdate: z.function().optional(),
-  afterUpdate: z.function().optional(),
-  beforeDelete: z.function().optional(),
-  afterDelete: z.function().optional(),
-});
-
-export type CollectionHooks = z.infer<typeof CollectionHooksSchema>;
-
-export const CollectionSchema = z.object({
-  slug: z.string(),
-  label: z.string().optional(),
-  icon: z.string().optional(),
-  apiPath: z.string().optional(),
-  fields: z.array(FieldSchema),
-  timestamps: z
-    .union([
-      z.boolean(),
-      z.object({
-        createdAt: z.string().optional(),
-        updatedAt: z.string().optional(),
-      }),
-    ])
-    .optional(),
-  auth: z.boolean().optional(),
-  hooks: CollectionHooksSchema.optional(),
-  access: AccessConfigSchema.optional(),
-  versions: z
-    .object({
-      drafts: z.boolean().optional(),
-      maxRevisions: z.number().optional(),
-      autosave: z.boolean().optional(),
-    })
-    .optional(),
-  webhooks: z
-    .array(
-      z.object({
-        events: z.array(z.string()),
-        url: z.string(),
-        headers: z.record(z.string(), z.string()).optional(),
-      }),
-    )
-    .optional(),
-  admin: z
-    .union([
-      z.boolean(),
-      z.object({
-        defaultColumns: z.array(z.string()).optional(),
-        useAsTitle: z.string().optional(),
-        hidden: z.boolean().optional(),
-        disableAdmin: z.boolean().optional(),
-        views: z
-          .array(
-            z.object({
-              name: z.string(),
-              filter: z.record(z.string(), z.any()),
-              defaultColumns: z.array(z.string()).optional(),
-            }),
-          )
-          .optional(),
-        bulkActions: z
-          .array(
-            z.object({
-              label: z.string(),
-              action: z.function(),
-            }),
-          )
-          .optional(),
-      }),
-    ])
-    .optional(),
-  hidden: z.boolean().optional(),
-});
-
-export type Collection = z.infer<typeof CollectionSchema>;
-
-export const GlobalSchema = z.object({
-  slug: z.string(),
-  label: z.string().optional(),
-  icon: z.string().optional(),
-  fields: z.array(FieldSchema),
-  timestamps: z
-    .union([
-      z.boolean(),
-      z.object({
-        createdAt: z.string().optional(),
-        updatedAt: z.string().optional(),
-      }),
-    ])
-    .optional(),
-  access: AccessConfigSchema.optional(),
-});
-
-export type Global = z.infer<typeof GlobalSchema>;
-
-export const AdminConfigSchema = z.object({
-  userCollection: z.string().optional(),
-  disableAdmin: z.boolean().optional(),
-  route: z.string().optional(),
-});
-
-export type AdminConfig = z.infer<typeof AdminConfigSchema>;
-
-export const OpacaAuthConfigSchema = z.object({
-  strategies: z
-    .object({
-      emailPassword: z.boolean().optional(),
-      magicLink: z
-        .object({
-          enabled: z.boolean(),
-          sendEmail: z.function(),
-        })
-        .optional(),
-    })
-    .optional(),
-  socialProviders: z
-    .object({
-      github: z
-        .object({
-          clientId: z.string(),
-          clientSecret: z.string(),
-        })
-        .optional(),
-      google: z
-        .object({
-          clientId: z.string(),
-          clientSecret: z.string(),
-        })
-        .optional(),
-    })
-    .optional(),
-  session: z
-    .object({
-      expiresInDays: z.number().optional(),
-      updateAgeSeconds: z.number().optional(),
-    })
-    .optional(),
-  features: z
-    .object({
-      apiKeys: z
-        .object({
-          enabled: z.boolean(),
-        })
-        .optional(),
-      mfa: z
-        .object({
-          enabled: z.boolean(),
-          issuer: z.string(),
-        })
-        .optional(),
-    })
-    .optional(),
-});
-
-export const ApiConfigSchema = z.object({
-  maxLimit: z.number().optional(),
-  rateLimit: z
-    .object({
-      windowMs: z.number().optional(),
-      limit: z.number().optional(),
-      enabled: z.boolean().optional(),
-      store: z.any().optional(),
-      provider: z.function().optional(),
-      keyGenerator: z.function().optional(),
-    })
-    .optional(),
-});
-
-export type ApiConfig = z.infer<typeof ApiConfigSchema>;
-
-export const OpacaConfigSchema = z.object({
-  collections: z.array(CollectionSchema),
-  globals: z.array(GlobalSchema).optional(),
-  db: z.any(),
-  storages: z.record(z.string(), z.any()).optional(),
-  runMigrationsOnStartup: z.boolean().optional(),
-  admin: AdminConfigSchema.optional(),
-  serverURL: z.string().optional(),
-  appName: z.string().optional(),
-  secret: z.string().optional(),
-  trustedOrigins: z.union([z.array(z.string()), z.function()]).optional(),
-  auth: OpacaAuthConfigSchema.optional(),
-  api: ApiConfigSchema.optional(),
-  access: z
-    .object({
-      roles: z.record(z.string(), z.record(z.string(), z.array(z.string()))).optional(),
-    })
-    .optional(),
-  i18n: z
-    .object({
-      locales: z.array(z.string()),
-      defaultLocale: z.string(),
-    })
-    .optional(),
-});
-
-export type OpacaConfig = z.infer<typeof OpacaConfigSchema>;

package/src/validator.ts

@@ -1,179 +0,0 @@
-import { z } from "zod";
-import type { Collection, Field } from "./types";
-
-export function generateSchemaForCollection(
-  collection: { fields: Field[]; versions?: any; timestamps?: any },
-  isUpdate: boolean = false,
-) {
-  const shape = mapFieldsToShape(collection.fields, isUpdate);
-
-  if (collection.versions) {
-    shape._status = z.enum(["draft", "published"]).optional().nullable();
-  }
-
-  const ts = collection.timestamps;
-  if (ts !== false && ts !== undefined) {
-    const config = typeof ts === "object" ? ts : {};
-    const createdField = config.createdAt || "createdAt";
-    const updatedField = config.updatedAt || "updatedAt";
-    shape[createdField] = z.union([z.string(), z.date()]).optional().nullable();
-    shape[updatedField] = z.union([z.string(), z.date()]).optional().nullable();
-  }
-
-  return z.object(shape);
-}
-
-function mapFieldsToShape(
-  fields: Field[],
-  isUpdate: boolean = false,
-): Record<string, z.ZodTypeAny> {
-  const shape: Record<string, z.ZodTypeAny> = {};
-
-  for (const field of fields) {
-    // Layout fields without name merge their fields into the current level
-    if (!field.name) {
-      if (field.type === "tabs" && field.tabs) {
-        for (const tab of field.tabs) {
-          Object.assign(shape, mapFieldsToShape(tab.fields, isUpdate));
-        }
-      } else if (field.type === "group" && field.fields) {
-        Object.assign(shape, mapFieldsToShape(field.fields, isUpdate));
-      } else if (field.type === "row" && field.fields) {
-        Object.assign(shape, mapFieldsToShape(field.fields, isUpdate));
-      } else if (field.type === "collapsible" && field.fields) {
-        Object.assign(shape, mapFieldsToShape(field.fields, isUpdate));
-      }
-      continue;
-    }
-
-    const fieldName = field.name;
-    let schema: z.ZodTypeAny;
-
-    if (field.type === "group" && field.fields) {
-      schema = z.object(mapFieldsToShape(field.fields, isUpdate));
-    } else if (field.type === "blocks" && field.blocks) {
-      const blockSchemas = field.blocks.map((block) =>
-        z.object({
-          blockType: z.literal(block.slug),
-          ...mapFieldsToShape(block.fields, isUpdate),
-        }),
-      );
-      schema = z.array(z.union(blockSchemas));
-    } else if (field.type === "row" || field.type === "collapsible") {
-      // If a row/collapsible HAS a name (unusual but possible), treat it as a group
-      if (field.fields) {
-        schema = z.object(mapFieldsToShape(field.fields, isUpdate));
-      } else {
-        schema = z.any();
-      }
-    } else {
-      schema = mapFieldToZod(field);
-    }
-
-    if (field.localized) {
-      schema = z.union([z.record(z.string(), schema), schema]);
-    }
-
-    if (field.required && !isUpdate) {
-      // Slugs with a 'from' source are not required during input as they are auto-generated
-      if (field.type === "slug" && (field as any).from) {
-        schema = schema.optional().nullable();
-      }
-    } else {
-      schema = schema.optional().nullable();
-    }
-
-    if (field.defaultValue !== undefined && !isUpdate) {
-      schema = schema.default(field.defaultValue);
-    }
-
-    if (field.validate) {
-      schema = schema.superRefine((val, ctx) => {
-        if (val === undefined || val === null) return;
-        const result = field.validate!(val);
-        if (result !== true) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: typeof result === "string" ? result : "Invalid field",
-          });
-        }
-      });
-    }
-
-    shape[fieldName] = schema;
-  }
-
-  return shape;
-}
-
-function mapFieldToZod(field: Field): z.ZodTypeAny {
-  switch (field.type) {
-    case "text":
-    case "slug":
-    case "richtext":
-    case "textarea":
-      return z.string();
-
-    case "relationship": {
-      const isHasMany = "hasMany" in field && field.hasMany;
-      const base = z.union([z.string(), z.number(), z.undefined(), z.null()]);
-
-      const schema = isHasMany ? z.array(base.optional().nullable()) : base;
-
-      if (isHasMany) {
-        return z.preprocess((val) => {
-          if (val === undefined || val === null || val === "") return [];
-          if (Array.isArray(val)) return val;
-          return [val];
-        }, schema);
-      }
-      return schema;
-    }
-
-    case "number":
-      return z.preprocess(
-        (val) => {
-          if (val === "" || val === undefined || val === null) return undefined;
-          if (typeof val === "string") {
-            const num = Number(val);
-            return Number.isNaN(num) ? undefined : num;
-          }
-          return val;
-        },
-        z.union([z.number(), z.undefined(), z.null()]),
-      );
-
-    case "boolean":
-      return z.preprocess((val) => {
-        if (typeof val === "string") return val === "true";
-        return val;
-      }, z.boolean());
-
-    case "date":
-      return z.preprocess(
-        (val) => {
-          if (val === "" || val === undefined || val === null) return undefined;
-          return val;
-        },
-        z.union([
-          z.string().regex(/^\d{4}-\d{2}-\d{2}/, "Invalid date format"),
-          z.date(),
-          z.undefined(),
-          z.null(),
-        ]),
-      );
-
-    case "select":
-      return z.string();
-
-    case "array":
-      return z.preprocess((val) => {
-        if (val === undefined || val === null || val === "") return [];
-        if (Array.isArray(val)) return val;
-        return [val];
-      }, z.array(z.any()));
-
-    default:
-      return z.any();
-  }
-}