opacacms 0.1.7 → 0.1.8

package/dist/index.js

@@ -1,11 +1,459 @@
-import {
-  OpacaError,
-  createClient
-} from "./chunk-d3ffeqp9.js";
-import {
-  defineConfig
-} from "./chunk-zvwb67nd.js";
-import"./chunk-8sqjbsgt.js";
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/client.ts
+class OpacaError extends Error {
+  status;
+  data;
+  constructor(message, status, data = {}) {
+    super(message);
+    this.name = "OpacaError";
+    this.status = status;
+    this.data = data;
+  }
+}
+function createClient(configOrOptions) {
+  const options = configOrOptions.serverURL ? { baseURL: configOrOptions.serverURL } : configOrOptions;
+  const baseURL = options.baseURL.replace(/\/$/, "");
+  const getHeaders = () => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (options.token) {
+      headers.Authorization = `Bearer ${options.token}`;
+    }
+    return headers;
+  };
+  const fetcher = async (path, init) => {
+    const res = await fetch(`${baseURL}${path}`, {
+      ...init,
+      credentials: "include",
+      headers: {
+        ...getHeaders(),
+        ...init?.headers
+      }
+    });
+    if (!res.ok) {
+      const errorData = await res.json().catch(() => ({}));
+      throw new OpacaError(errorData.message || `API Error: ${res.status}`, res.status, errorData);
+    }
+    return res.json();
+  };
+  const client = {
+    getMetadata: () => fetcher("/api/__admin/metadata"),
+    getCollections: () => fetcher("/api/__admin/collections"),
+    getSetupStatus: () => fetcher("/api/__admin/setup"),
+    collections: new Proxy({}, {
+      get(_, collectionSlug) {
+        return {
+          find: (query) => {
+            const searchParams = new URLSearchParams;
+            if (query) {
+              Object.entries(query).forEach(([key, value]) => {
+                searchParams.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+              });
+            }
+            const queryString = searchParams.toString();
+            return fetcher(`/api/${String(collectionSlug)}${queryString ? `?${queryString}` : ""}`);
+          },
+          findOne: (id) => fetcher(`/api/${String(collectionSlug)}/${id}`),
+          list: () => fetcher(`/api/${String(collectionSlug)}`),
+          create: (data) => fetcher(`/api/${String(collectionSlug)}`, {
+            method: "POST",
+            body: JSON.stringify(data)
+          }),
+          update: (id, data) => fetcher(`/api/${String(collectionSlug)}/${id}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+          }),
+          delete: (id) => fetcher(`/api/${String(collectionSlug)}/${id}`, {
+            method: "DELETE"
+          })
+        };
+      }
+    }),
+    globals: new Proxy({}, {
+      get(_, globalSlug) {
+        return {
+          get: () => fetcher(`/api/globals/${String(globalSlug)}`),
+          update: (data) => fetcher(`/api/globals/${String(globalSlug)}`, {
+            method: "PATCH",
+            body: JSON.stringify(data)
+          })
+        };
+      }
+    })
+  };
+  return client;
+}
+// src/validation.ts
+import { z } from "zod";
+var FieldTypeSchema = z.enum([
+  "text",
+  "slug",
+  "textarea",
+  "number",
+  "richtext",
+  "relationship",
+  "select",
+  "radio",
+  "date",
+  "boolean",
+  "json",
+  "file",
+  "blocks",
+  "group",
+  "row",
+  "collapsible",
+  "tabs",
+  "join",
+  "array",
+  "virtual"
+]);
+var 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()
+});
+var FieldSchema = z.lazy(() => z.discriminatedUnion("type", [
+  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()
+  }),
+  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))
+  }),
+  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))
+    }))
+  }),
+  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()
+  })
+]));
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var AdminConfigSchema = z.object({
+  userCollection: z.string().optional(),
+  disableAdmin: z.boolean().optional(),
+  route: z.string().optional()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+
+// src/config.ts
+function recursivelyBuild(obj) {
+  if (!obj || typeof obj !== "object")
+    return obj;
+  if (typeof obj.build === "function") {
+    return recursivelyBuild(obj.build());
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(recursivelyBuild);
+  }
+  if (obj.constructor !== Object) {
+    return obj;
+  }
+  const built = {};
+  for (const [key, value] of Object.entries(obj)) {
+    built[key] = recursivelyBuild(value);
+  }
+  return built;
+}
+function defineConfig(config) {
+  const builtConfig = recursivelyBuild(config);
+  const result = OpacaConfigSchema.safeParse(builtConfig);
+  if (!result.success) {
+    throw new Error(`Invalid OpacaCMS Configuration: ${result.error.message}`);
+  }
+  return builtConfig;
+}
 export {
   defineConfig,
   createClient,