opacacms 0.1.0

package/src/validation.ts

@@ -0,0 +1,429 @@
+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

@@ -0,0 +1,179 @@
+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();
+  }
+}