@momentumcms/core 0.0.1

package/index.cjs

@@ -0,0 +1,730 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  LAYOUT_FIELD_TYPES: () => LAYOUT_FIELD_TYPES,
+  MIN_PASSWORD_LENGTH: () => MIN_PASSWORD_LENGTH,
+  MediaCollection: () => MediaCollection,
+  ReferentialIntegrityError: () => ReferentialIntegrityError,
+  SEED_TRACKING_COLLECTION_SLUG: () => SEED_TRACKING_COLLECTION_SLUG,
+  SeedConflictError: () => SeedConflictError,
+  SeedRollbackError: () => SeedRollbackError,
+  access: () => access,
+  allowAll: () => allowAll,
+  and: () => and,
+  array: () => array,
+  blocks: () => blocks,
+  checkbox: () => checkbox,
+  collapsible: () => collapsible,
+  createSeedHelpers: () => createSeedHelpers,
+  date: () => date,
+  defineCollection: () => defineCollection,
+  defineGlobal: () => defineGlobal,
+  defineMomentumConfig: () => defineMomentumConfig,
+  denyAll: () => denyAll,
+  email: () => email,
+  flattenDataFields: () => flattenDataFields,
+  getCollections: () => getCollections,
+  getDbAdapter: () => getDbAdapter,
+  getGlobals: () => getGlobals,
+  getSoftDeleteField: () => getSoftDeleteField,
+  group: () => group,
+  hasAllRoles: () => hasAllRoles,
+  hasAnyRole: () => hasAnyRole,
+  hasRole: () => hasRole,
+  humanizeFieldName: () => humanizeFieldName,
+  isAuthenticated: () => isAuthenticated,
+  isLayoutField: () => isLayoutField,
+  isOwner: () => isOwner,
+  json: () => json,
+  not: () => not,
+  number: () => number,
+  or: () => or,
+  password: () => password,
+  point: () => point,
+  radio: () => radio,
+  relationship: () => relationship,
+  richText: () => richText,
+  row: () => row,
+  select: () => select,
+  slug: () => slug,
+  tabs: () => tabs,
+  text: () => text,
+  textarea: () => textarea,
+  upload: () => upload,
+  validateFieldConstraints: () => validateFieldConstraints
+});
+module.exports = __toCommonJS(src_exports);
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+function defineGlobal(config) {
+  if (!config.slug) {
+    throw new Error("Global must have a slug");
+  }
+  if (!config.fields || config.fields.length === 0) {
+    throw new Error(`Global "${config.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(config.slug)) {
+    throw new Error(
+      `Global slug "${config.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return config;
+}
+function getSoftDeleteField(config) {
+  if (!config.softDelete)
+    return null;
+  if (config.softDelete === true)
+    return "deletedAt";
+  const sdConfig = config.softDelete;
+  return sdConfig.field ?? "deletedAt";
+}
+
+// libs/core/src/lib/fields/field.types.ts
+var LAYOUT_FIELD_TYPES = /* @__PURE__ */ new Set(["tabs", "collapsible", "row"]);
+var ReferentialIntegrityError = class extends Error {
+  constructor(table, constraint) {
+    super(`Cannot delete from "${table}": referenced by foreign key constraint "${constraint}"`);
+    this.name = "ReferentialIntegrityError";
+    this.table = table;
+    this.constraint = constraint;
+  }
+};
+function isLayoutField(field) {
+  return LAYOUT_FIELD_TYPES.has(field.type);
+}
+function flattenDataFields(fields) {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "tabs") {
+      for (const tab of field.tabs) {
+        result.push(...flattenDataFields(tab.fields));
+      }
+    } else if (field.type === "collapsible" || field.type === "row") {
+      result.push(...flattenDataFields(field.fields));
+    } else {
+      result.push(field);
+    }
+  }
+  return result;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function textarea(name, options = {}) {
+  return {
+    name,
+    type: "textarea",
+    ...options
+  };
+}
+function richText(name, options = {}) {
+  return {
+    name,
+    type: "richText",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function date(name, options = {}) {
+  return {
+    name,
+    type: "date",
+    ...options
+  };
+}
+function checkbox(name, options = {}) {
+  return {
+    name,
+    type: "checkbox",
+    ...options,
+    defaultValue: options.defaultValue ?? false
+  };
+}
+function select(name, options) {
+  return {
+    name,
+    type: "select",
+    ...options
+  };
+}
+function radio(name, options) {
+  return {
+    name,
+    type: "radio",
+    ...options
+  };
+}
+function email(name, options = {}) {
+  return {
+    name,
+    type: "email",
+    ...options
+  };
+}
+function password(name, options = {}) {
+  return {
+    name,
+    type: "password",
+    ...options
+  };
+}
+function upload(name, options = {}) {
+  return {
+    name,
+    type: "upload",
+    relationTo: options.relationTo ?? "media",
+    ...options
+  };
+}
+function relationship(name, options) {
+  return {
+    name,
+    type: "relationship",
+    ...options
+  };
+}
+function array(name, options) {
+  return {
+    name,
+    type: "array",
+    ...options
+  };
+}
+function group(name, options) {
+  return {
+    name,
+    type: "group",
+    ...options
+  };
+}
+function blocks(name, options) {
+  return {
+    name,
+    type: "blocks",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+function point(name, options = {}) {
+  return {
+    name,
+    type: "point",
+    ...options
+  };
+}
+function slug(name, options) {
+  return {
+    name,
+    type: "slug",
+    ...options
+  };
+}
+function tabs(name, options) {
+  return {
+    name,
+    type: "tabs",
+    ...options
+  };
+}
+function collapsible(name, options) {
+  return {
+    name,
+    type: "collapsible",
+    ...options
+  };
+}
+function row(name, options) {
+  return {
+    name,
+    type: "row",
+    ...options
+  };
+}
+
+// libs/core/src/lib/fields/humanize-field-name.ts
+function humanizeFieldName(name) {
+  if (!name)
+    return "";
+  return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase()).trim();
+}
+
+// libs/core/src/lib/fields/field-validators.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function validateFieldConstraints(field, value) {
+  if (value === null || value === void 0) {
+    return [];
+  }
+  const label = field.label ?? humanizeFieldName(field.name);
+  const errors = [];
+  switch (field.type) {
+    case "text":
+    case "textarea":
+      if (typeof value === "string") {
+        validateStringLength(field.name, label, value, field.minLength, field.maxLength, errors);
+      }
+      break;
+    case "password":
+      if (typeof value === "string" && field.minLength !== void 0) {
+        validateStringLength(field.name, label, value, field.minLength, void 0, errors);
+      }
+      break;
+    case "number":
+      if (typeof value === "number") {
+        if (field.min !== void 0 && value < field.min) {
+          errors.push({ field: field.name, message: `${label} must be at least ${field.min}` });
+        }
+        if (field.max !== void 0 && value > field.max) {
+          errors.push({
+            field: field.name,
+            message: `${label} must be no more than ${field.max}`
+          });
+        }
+        if (field.step !== void 0 && field.step > 0) {
+          const remainder = Math.abs(Math.round(value / field.step * 1e10) % Math.round(1e10));
+          if (remainder > 1) {
+            errors.push({
+              field: field.name,
+              message: `${label} must be a multiple of ${field.step}`
+            });
+          }
+        }
+      }
+      break;
+    case "email":
+      if (typeof value === "string" && value !== "" && !EMAIL_REGEX.test(value)) {
+        errors.push({
+          field: field.name,
+          message: `${label} must be a valid email address`
+        });
+      }
+      break;
+    case "select":
+      validateSelectOptions(field.name, label, value, field.options, field.hasMany, errors);
+      break;
+    case "radio":
+      validateSelectOptions(field.name, label, value, field.options, false, errors);
+      break;
+    case "array":
+      if (Array.isArray(value)) {
+        validateRowCount(field.name, label, value.length, field.minRows, field.maxRows, errors);
+      }
+      break;
+    case "blocks":
+      if (Array.isArray(value)) {
+        validateRowCount(field.name, label, value.length, field.minRows, field.maxRows, errors);
+      }
+      break;
+  }
+  return errors;
+}
+function validateStringLength(name, label, value, minLength, maxLength, errors) {
+  if (minLength !== void 0 && value.length < minLength) {
+    errors.push({ field: name, message: `${label} must be at least ${minLength} characters` });
+  }
+  if (maxLength !== void 0 && value.length > maxLength) {
+    errors.push({
+      field: name,
+      message: `${label} must be no more than ${maxLength} characters`
+    });
+  }
+}
+function validateSelectOptions(name, label, value, options, hasMany, errors) {
+  if (value === "")
+    return;
+  const validValues = new Set(options.map((o) => o.value));
+  if (hasMany && Array.isArray(value)) {
+    const allValid = value.every((v) => validValues.has(v));
+    if (!allValid) {
+      errors.push({ field: name, message: `${label} has an invalid selection` });
+    }
+  } else if (!Array.isArray(value)) {
+    if (!validValues.has(value)) {
+      errors.push({ field: name, message: `${label} has an invalid selection` });
+    }
+  }
+}
+function validateRowCount(name, label, count, minRows, maxRows, errors) {
+  if (minRows !== void 0 && count < minRows) {
+    errors.push({ field: name, message: `${label} requires at least ${minRows} rows` });
+  }
+  if (maxRows !== void 0 && count > maxRows) {
+    errors.push({ field: name, message: `${label} allows at most ${maxRows} rows` });
+  }
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      required: true,
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/core/src/lib/access/access-helpers.ts
+function access(callback) {
+  return ({ req, id, data }) => {
+    const user = req.user;
+    return callback({ user, id, data });
+  };
+}
+function allowAll() {
+  return () => true;
+}
+function denyAll() {
+  return () => false;
+}
+function isAuthenticated() {
+  return ({ req }) => !!req.user;
+}
+function hasRole(role) {
+  return ({ req }) => req.user?.role === role;
+}
+function hasAnyRole(roles) {
+  return ({ req }) => {
+    const userRole = req.user?.role;
+    return userRole !== void 0 && roles.includes(userRole);
+  };
+}
+function hasAllRoles(roles) {
+  return ({ req }) => {
+    const userRoles = req.user?.["roles"];
+    if (!Array.isArray(userRoles))
+      return false;
+    return roles.every((role) => userRoles.includes(role));
+  };
+}
+function and(...fns) {
+  return async (args) => {
+    for (const fn of fns) {
+      const result = await fn(args);
+      if (!result)
+        return false;
+    }
+    return true;
+  };
+}
+function or(...fns) {
+  return async (args) => {
+    for (const fn of fns) {
+      const result = await fn(args);
+      if (result)
+        return true;
+    }
+    return false;
+  };
+}
+function not(fn) {
+  return async (args) => {
+    const result = await fn(args);
+    return !result;
+  };
+}
+function isOwner(ownerField = "createdBy") {
+  return ({ req, data }) => {
+    if (!req.user?.id)
+      return false;
+    const ownerId = data?.[ownerField];
+    if (ownerId === void 0 || ownerId === null)
+      return false;
+    return ownerId === req.user.id || String(ownerId) === String(req.user.id);
+  };
+}
+
+// libs/core/src/lib/config.ts
+var MIN_PASSWORD_LENGTH = 8;
+function defineMomentumConfig(config) {
+  return {
+    ...config,
+    admin: {
+      basePath: config.admin?.basePath ?? "/admin",
+      branding: config.admin?.branding ?? {},
+      toasts: config.admin?.toasts ?? true
+    },
+    server: {
+      port: config.server?.port ?? 3e3,
+      cors: config.server?.cors ?? {
+        origin: "*",
+        methods: ["GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"],
+        headers: ["Content-Type", "Authorization", "X-API-Key"]
+      }
+    },
+    seeding: config.seeding ? {
+      ...config.seeding,
+      options: {
+        onConflict: config.seeding.options?.onConflict ?? "skip",
+        runOnStart: config.seeding.options?.runOnStart ?? "development",
+        quiet: config.seeding.options?.quiet ?? false
+      }
+    } : void 0,
+    logging: {
+      level: config.logging?.level ?? "info",
+      format: config.logging?.format ?? "pretty",
+      timestamps: config.logging?.timestamps ?? true
+    }
+  };
+}
+function getDbAdapter(config) {
+  return config.db.adapter;
+}
+function getCollections(config) {
+  return config.collections;
+}
+function getGlobals(config) {
+  return config.globals ?? [];
+}
+
+// libs/core/src/lib/seeding/seeding.types.ts
+var SEED_TRACKING_COLLECTION_SLUG = "_momentum_seeds";
+var SeedConflictError = class extends Error {
+  constructor(seedId, collection) {
+    super(`Seed conflict: seedId "${seedId}" already exists in collection "${collection}"`);
+    this.name = "SeedConflictError";
+    this.seedId = seedId;
+    this.collection = collection;
+  }
+};
+var SeedRollbackError = class extends Error {
+  constructor(originalError, rolledBackSeeds, rollbackFailures) {
+    const rollbackStatus = rollbackFailures.length > 0 ? `Rollback partially failed: ${rolledBackSeeds.length} rolled back, ${rollbackFailures.length} failed` : `Rollback successful: ${rolledBackSeeds.length} seeds removed`;
+    super(`Seeding failed: ${originalError.message}. ${rollbackStatus}`);
+    this.name = "SeedRollbackError";
+    this.originalError = originalError;
+    this.rolledBackSeeds = rolledBackSeeds;
+    this.rollbackFailures = rollbackFailures;
+  }
+};
+
+// libs/core/src/lib/seeding/seed-helpers.ts
+function createSeedHelpers() {
+  return {
+    admin(seedId, data, options) {
+      return {
+        seedId,
+        collection: "user",
+        // Better Auth user table
+        data: {
+          role: "admin",
+          // Admin role by default
+          emailVerified: true,
+          // Admins are pre-verified
+          ...data
+        },
+        options
+      };
+    },
+    user(seedId, data, options) {
+      return {
+        seedId,
+        collection: "user",
+        // Better Auth user table
+        data: {
+          role: "user",
+          // Default role
+          emailVerified: false,
+          // Default not verified
+          ...data
+        },
+        options
+      };
+    },
+    authUser(seedId, data, options) {
+      return {
+        seedId,
+        collection: "user",
+        // Better Auth user table (auth-user collection with dbName: 'user')
+        data: {
+          role: "user",
+          emailVerified: true,
+          ...data
+        },
+        options: {
+          ...options,
+          useAuthSignup: true
+        }
+      };
+    },
+    collection(slug2) {
+      return {
+        create(seedId, data, options) {
+          return {
+            seedId,
+            collection: slug2,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- User provides partial data that will be merged with defaults during seeding
+            data,
+            options
+          };
+        }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAYOUT_FIELD_TYPES,
+  MIN_PASSWORD_LENGTH,
+  MediaCollection,
+  ReferentialIntegrityError,
+  SEED_TRACKING_COLLECTION_SLUG,
+  SeedConflictError,
+  SeedRollbackError,
+  access,
+  allowAll,
+  and,
+  array,
+  blocks,
+  checkbox,
+  collapsible,
+  createSeedHelpers,
+  date,
+  defineCollection,
+  defineGlobal,
+  defineMomentumConfig,
+  denyAll,
+  email,
+  flattenDataFields,
+  getCollections,
+  getDbAdapter,
+  getGlobals,
+  getSoftDeleteField,
+  group,
+  hasAllRoles,
+  hasAnyRole,
+  hasRole,
+  humanizeFieldName,
+  isAuthenticated,
+  isLayoutField,
+  isOwner,
+  json,
+  not,
+  number,
+  or,
+  password,
+  point,
+  radio,
+  relationship,
+  richText,
+  row,
+  select,
+  slug,
+  tabs,
+  text,
+  textarea,
+  upload,
+  validateFieldConstraints
+});