@momentumcms/core 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momentumcms/core",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Core collection config, fields, hooks, and access control for Momentum CMS",
   "license": "MIT",
   "author": "Momentum CMS Contributors",
@@ -28,7 +28,7 @@
   "main": "./index.cjs",
   "types": "./src/index.d.ts",
   "bin": {
-    "momentum-generate-types": "./generators/types/generator.cjs"
+    "momentum-generate": "./generators/generator.cjs"
   },
   "dependencies": {},
   "module": "./index.js"

package/src/generators/field-to-typescript.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Field-to-TypeScript mapping utilities for Momentum CMS code generation.
+ *
+ * Converts collection/global field definitions into TypeScript type strings.
+ * Handles layout field flattening, block discriminated unions, and where clauses.
+ */
+import type { Field, BlocksField } from '../lib/fields/field.types';
+/**
+ * Convert a slug like 'auth-user' to PascalCase like 'AuthUser'.
+ * Strips any characters that are not valid in a TypeScript identifier.
+ */
+export declare function slugToPascalCase(slug: string): string;
+/**
+ * Safely quote a string value for use in generated TypeScript.
+ * Uses JSON.stringify to handle escaping (produces double-quoted strings).
+ */
+export declare function safeQuote(value: string | number): string;
+/**
+ * Map a single field to its TypeScript type string.
+ */
+export declare function fieldTypeToTS(field: Field): string;
+/**
+ * Generate interface field lines from an array of field definitions.
+ * Flattens layout fields (tabs, collapsible, row) before processing.
+ */
+export declare function generateFieldsInterface(fields: Field[], indent?: string): string;
+/**
+ * Generate discriminated union types for a blocks field.
+ *
+ * Returns the block interface definitions and union type as a string,
+ * plus the union type name to use in the parent interface.
+ */
+export declare function generateBlockTypes(collectionName: string, fieldName: string, blocksField: BlocksField): {
+    declarations: string;
+    unionTypeName: string;
+};
+/**
+ * Get the where clause type for a field based on its type.
+ */
+export declare function getFieldWhereType(field: Field): string;
+/**
+ * Generate a where clause interface for a collection.
+ */
+export declare function generateWhereClauseInterface(slug: string, fields: Field[], hasTimestamps: boolean): string;

package/src/generators/generator.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Momentum CMS Unified Code Generator
+ *
+ * Single-pass generator that reads momentum.config.ts and produces two output files:
+ * 1. Types file (--types): TypeScript interfaces for all collections + globals
+ * 2. Admin config file (--config): Browser-safe Angular config with inlined, stripped collections
+ *
+ * Usage:
+ *   npx tsx generator.ts <configPath> --types <typesOutput> --config <configOutput> [--watch]
+ */
+interface FieldDefinition {
+    name: string;
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    hasMany?: boolean;
+    label?: string;
+    description?: string;
+    options?: Array<{
+        value: string | number;
+        label?: string;
+    }>;
+    fields?: FieldDefinition[];
+    blocks?: Array<{
+        slug: string;
+        fields: FieldDefinition[];
+        labels?: {
+            singular?: string;
+            plural?: string;
+        };
+        editor?: Record<string, unknown>;
+    }>;
+    tabs?: Array<{
+        label: string;
+        description?: string;
+        fields: FieldDefinition[];
+    }>;
+    collection?: () => unknown;
+    relationTo?: string | Array<() => unknown>;
+    from?: string;
+    defaultValue?: unknown;
+    defaultOpen?: boolean;
+    onDelete?: string;
+    filterOptions?: unknown;
+    admin?: Record<string, unknown>;
+    access?: unknown;
+    hooks?: unknown;
+    validate?: unknown;
+    displayFormat?: Record<string, unknown>;
+    minLength?: number;
+    maxLength?: number;
+    rows?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    minRows?: number;
+    maxRows?: number;
+    displayField?: string;
+    mimeTypes?: string[];
+    maxSize?: number;
+}
+interface CollectionDefinition {
+    slug: string;
+    labels?: {
+        singular?: string;
+        plural?: string;
+    };
+    fields: FieldDefinition[];
+    admin?: Record<string, unknown>;
+    access?: unknown;
+    hooks?: unknown;
+    auth?: unknown;
+    timestamps?: boolean | {
+        createdAt?: boolean;
+        updatedAt?: boolean;
+    };
+    versions?: boolean | {
+        drafts?: boolean;
+        maxPerDoc?: number;
+    };
+    softDelete?: boolean | {
+        field?: string;
+        retentionDays?: number;
+    };
+    managed?: boolean;
+    dbName?: string;
+    indexes?: unknown[];
+    defaultSort?: string;
+    graphQL?: unknown;
+    defaultWhere?: unknown;
+    endpoints?: unknown[];
+    webhooks?: unknown[];
+}
+interface GlobalDefinition {
+    slug: string;
+    label?: string;
+    fields: FieldDefinition[];
+    admin?: Record<string, unknown>;
+    access?: unknown;
+    hooks?: unknown;
+    versions?: boolean | {
+        drafts?: boolean;
+    };
+}
+interface PluginBrowserImport {
+    path: string;
+    exportName: string;
+}
+interface PluginBrowserImports {
+    collections?: PluginBrowserImport;
+    adminRoutes?: PluginBrowserImport;
+    modifyCollections?: PluginBrowserImport;
+}
+interface PluginDescriptor {
+    name: string;
+    collections?: Array<{
+        slug: string;
+        fields?: FieldDefinition[];
+    }>;
+    adminRoutes?: Array<{
+        path: string;
+        loadComponent: unknown;
+        data?: Record<string, unknown>;
+        label: string;
+        icon: string;
+        group?: string;
+    }>;
+    modifyCollections?(collections: unknown[]): void;
+    browserImports?: PluginBrowserImports;
+}
+interface MomentumConfig {
+    collections: CollectionDefinition[];
+    globals?: GlobalDefinition[];
+    admin?: {
+        basePath?: string;
+        branding?: {
+            logo?: string;
+            title?: string;
+        };
+        toasts?: boolean;
+    };
+    plugins?: PluginDescriptor[];
+}
+interface GeneratorOptions {
+    configPath: string;
+    typesOutputPath: string;
+    configOutputPath: string;
+    watch?: boolean;
+}
+/**
+ * Generate TypeScript types from collection and global definitions.
+ */
+export declare function generateTypes(config: MomentumConfig): string;
+/**
+ * Serialize a value to a TypeScript literal string.
+ * Skips functions and undefined values.
+ */
+export declare function serializeValue(value: unknown, indent?: string): string;
+/**
+ * Serialize a field definition, stripping server-only properties.
+ * For relationship fields, resolves collection() at build time into an inline stub.
+ */
+export declare function serializeField(field: FieldDefinition, indent?: string): string;
+/**
+ * Serialize a collection definition, stripping server-only properties.
+ */
+export declare function serializeCollection(collection: CollectionDefinition, indent?: string): string;
+/**
+ * Serialize a global definition, stripping server-only properties.
+ */
+export declare function serializeGlobal(global: GlobalDefinition, indent?: string): string;
+/**
+ * Compute a relative import path from one file to another (without .ts extension).
+ */
+export declare function computeRelativeImport(fromFile: string, toFile: string): string;
+/**
+ * Generate the browser-safe admin config TypeScript file.
+ * Collections and globals are inlined with server-only properties stripped.
+ * Only plugin admin routes are still imported (they have loadComponent functions).
+ */
+export declare function generateAdminConfig(config: MomentumConfig, typesRelPath: string): string;
+export default function runGenerator(options: GeneratorOptions): Promise<{
+    success: boolean;
+}>;
+export {};

package/src/lib/config.d.ts

@@ -1,7 +1,7 @@
 import type { CollectionConfig, GlobalConfig } from './collections';
 import type { SeedingConfig, SeedingOptions } from './seeding';
 import type { DocumentVersion, DocumentStatus, VersionQueryOptions, VersionCountOptions, CreateVersionOptions } from './versions';
-import type { MomentumPlugin } from './plugins';
+import type { MomentumPlugin, PluginAdminRouteDescriptor } from './plugins';
 import type { StorageAdapter } from './storage';
 /**
  * Minimum password length for user accounts.
@@ -251,6 +251,39 @@ export interface LoggingConfig {
  * Resolved logging config with defaults applied.
  */
 export type ResolvedLoggingConfig = Required<LoggingConfig>;
+/**
+ * Browser-safe plugin descriptor for admin UI.
+ * Contains only static data needed for admin route generation.
+ */
+export interface AdminPluginDescriptor {
+    /** Unique plugin name */
+    name: string;
+    /** Static collections declared by this plugin */
+    collections?: CollectionConfig[];
+    /** Static admin routes declared by this plugin */
+    adminRoutes?: PluginAdminRouteDescriptor[];
+    /** Synchronously transform the merged collections at config time */
+    modifyCollections?(collections: CollectionConfig[]): void;
+}
+/**
+ * Browser-safe config for admin route generation.
+ * Contains only the data needed by `momentumAdminRoutes()` — no db/storage/server.
+ * This is the output type of the unified `generate` Nx executor (--config output).
+ */
+export interface MomentumAdminConfig<CS extends string = string, GS extends string = string> {
+    /** Collection definitions */
+    collections: Array<CollectionConfig & {
+        slug: CS;
+    }>;
+    /** Global definitions (singleton documents) */
+    globals?: Array<GlobalConfig & {
+        slug: GS;
+    }>;
+    /** Admin panel configuration */
+    admin?: AdminPanelConfig;
+    /** Browser-safe plugin descriptors */
+    plugins?: AdminPluginDescriptor[];
+}
 /**
  * Momentum CMS configuration.
  */

package/src/lib/plugins.d.ts

@@ -173,4 +173,27 @@ export interface MomentumPlugin {
     onReady?(context: PluginReadyContext): void | Promise<void>;
     /** Called on graceful shutdown. Clean up resources. */
     onShutdown?(context: PluginContext): void | Promise<void>;
+    /** Browser-safe import descriptors for the admin config generator.
+     *  Tells the generator where to import collections, admin routes, and
+     *  modifyCollections from browser-safe sub-paths instead of the main
+     *  server-only entry point. */
+    browserImports?: PluginBrowserImports;
+}
+/** A single browser-safe import descriptor for a plugin export. */
+export interface PluginBrowserImport {
+    /** The import path (e.g., '@momentumcms/auth/collections') */
+    path: string;
+    /** The named export to import (e.g., 'BASE_AUTH_COLLECTIONS') */
+    exportName: string;
+}
+/** Browser-safe import map for the admin config generator.
+ *  Plugins declare which sub-paths expose browser-safe versions
+ *  of their collections, admin routes, and modifyCollections. */
+export interface PluginBrowserImports {
+    /** Import path for browser-safe plugin collections */
+    collections?: PluginBrowserImport;
+    /** Import path for browser-safe plugin admin routes */
+    adminRoutes?: PluginBrowserImport;
+    /** Import path for browser-safe modifyCollections function */
+    modifyCollections?: PluginBrowserImport;
 }

package/generators/types/generator.cjs

@@ -1,292 +0,0 @@
-"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/generators/types/generator.ts
-var generator_exports = {};
-__export(generator_exports, {
-  default: () => runExecutor
-});
-module.exports = __toCommonJS(generator_exports);
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
-var import_node_url = require("node:url");
-function fieldTypeToTS(field) {
-  switch (field.type) {
-    case "text":
-    case "textarea":
-    case "richText":
-    case "email":
-    case "password":
-    case "slug":
-      return "string";
-    case "number":
-      return "number";
-    case "checkbox":
-      return "boolean";
-    case "date":
-      return "string";
-    case "select":
-    case "radio":
-      if (field.options && field.options.length > 0) {
-        return field.options.map((opt) => `'${opt.value}'`).join(" | ");
-      }
-      return "string";
-    case "relationship": {
-      const baseType = "string";
-      return field.hasMany ? `${baseType}[]` : baseType;
-    }
-    case "upload":
-      return field.hasMany ? "string[]" : "string";
-    case "array":
-      if (field.fields && field.fields.length > 0) {
-        const arrayItemType = generateFieldsInterface(field.fields, "  ");
-        return `Array<{
-${arrayItemType}
-  }>`;
-      }
-      return "unknown[]";
-    case "group":
-      if (field.fields && field.fields.length > 0) {
-        const groupType = generateFieldsInterface(field.fields, "  ");
-        return `{
-${groupType}
-  }`;
-      }
-      return "Record<string, unknown>";
-    case "blocks":
-      return "unknown[]";
-    case "json":
-      return "Record<string, unknown>";
-    case "point":
-      return "[number, number]";
-    default:
-      return "unknown";
-  }
-}
-function generateFieldsInterface(fields, indent = "") {
-  return fields.map((field) => {
-    const tsType = fieldTypeToTS(field);
-    const optional = field.required ? "" : "?";
-    return `${indent}  ${field.name}${optional}: ${tsType};`;
-  }).join("\n");
-}
-function slugToPascalCase(slug) {
-  return slug.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function getFieldWhereType(field) {
-  switch (field.type) {
-    case "text":
-    case "textarea":
-    case "richText":
-    case "email":
-    case "slug":
-      return `string | { equals?: string; not?: string; contains?: string; in?: string[] }`;
-    case "number":
-      return `number | { equals?: number; not?: number; gt?: number; gte?: number; lt?: number; lte?: number; in?: number[] }`;
-    case "checkbox":
-      return `boolean | { equals?: boolean }`;
-    case "date":
-      return `string | { equals?: string; not?: string; gt?: string; gte?: string; lt?: string; lte?: string }`;
-    case "select":
-    case "radio":
-      if (field.options && field.options.length > 0) {
-        const options = field.options.map((opt) => `'${opt.value}'`).join(" | ");
-        return `${options} | { equals?: ${options}; not?: ${options}; in?: (${options})[] }`;
-      }
-      return `string | { equals?: string; in?: string[] }`;
-    case "relationship":
-      return `string | { equals?: string; not?: string; in?: string[] }`;
-    default:
-      return "unknown";
-  }
-}
-function generateWhereClauseInterface(collection) {
-  const interfaceName = slugToPascalCase(collection.slug);
-  const lines = [];
-  lines.push(`/**`);
-  lines.push(` * Where clause type for querying the "${collection.slug}" collection.`);
-  lines.push(` */`);
-  lines.push(`export interface ${interfaceName}WhereClause {`);
-  lines.push(`  id?: string | { equals?: string; not?: string; in?: string[] };`);
-  for (const field of collection.fields) {
-    const whereType = getFieldWhereType(field);
-    lines.push(`  ${field.name}?: ${whereType};`);
-  }
-  const hasTimestamps = collection.timestamps !== false;
-  if (hasTimestamps) {
-    lines.push(
-      `  createdAt?: string | { equals?: string; gt?: string; gte?: string; lt?: string; lte?: string };`
-    );
-    lines.push(
-      `  updatedAt?: string | { equals?: string; gt?: string; gte?: string; lt?: string; lte?: string };`
-    );
-  }
-  lines.push(`}`);
-  return lines.join("\n");
-}
-function generateTypes(config) {
-  const lines = [
-    "/**",
-    " * Auto-generated types from Momentum CMS collection definitions.",
-    " * DO NOT EDIT - This file is regenerated when collections change.",
-    ` * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    " */",
-    ""
-  ];
-  for (const collection of config.collections) {
-    const interfaceName = slugToPascalCase(collection.slug);
-    lines.push(`/**`);
-    lines.push(` * Document type for the "${collection.slug}" collection.`);
-    lines.push(` */`);
-    lines.push(`export interface ${interfaceName} {`);
-    lines.push(`  /** Unique document identifier */`);
-    lines.push(`  id: string;`);
-    const fieldsCode = generateFieldsInterface(collection.fields);
-    if (fieldsCode) {
-      lines.push(fieldsCode);
-    }
-    const hasTimestamps = collection.timestamps !== false;
-    if (hasTimestamps) {
-      lines.push(`  /** Document creation timestamp */`);
-      lines.push(`  createdAt: string;`);
-      lines.push(`  /** Document last update timestamp */`);
-      lines.push(`  updatedAt: string;`);
-    }
-    lines.push(`}`);
-    lines.push("");
-  }
-  for (const collection of config.collections) {
-    lines.push(generateWhereClauseInterface(collection));
-    lines.push("");
-  }
-  lines.push(`/**`);
-  lines.push(` * All collection slugs in this Momentum CMS instance.`);
-  lines.push(` */`);
-  const slugs = config.collections.map((c) => `'${c.slug}'`).join(" | ");
-  lines.push(`export type CollectionSlug = ${slugs || "never"};`);
-  lines.push("");
-  lines.push(`/**`);
-  lines.push(` * Mapping from collection slug to document type.`);
-  lines.push(` */`);
-  lines.push(`export interface MomentumCollections {`);
-  for (const collection of config.collections) {
-    const interfaceName = slugToPascalCase(collection.slug);
-    lines.push(`  '${collection.slug}': ${interfaceName};`);
-  }
-  lines.push(`}`);
-  lines.push("");
-  lines.push(`/**`);
-  lines.push(` * Type-safe collection mapping for use with injectTypedMomentumAPI().`);
-  lines.push(` * Includes both document types and where clause types.`);
-  lines.push(` *`);
-  lines.push(` * @example`);
-  lines.push(` * \`\`\`typescript`);
-  lines.push(` * import { injectTypedMomentumAPI } from '@momentumcms/admin';`);
-  lines.push(` * import type { TypedMomentumCollections } from './types/momentum.generated';`);
-  lines.push(` *`);
-  lines.push(` * const api = injectTypedMomentumAPI<TypedMomentumCollections>();`);
-  lines.push(` * const posts = await api.posts.find({ where: { status: 'published' } });`);
-  lines.push(` * \`\`\``);
-  lines.push(` */`);
-  lines.push(`export type TypedMomentumCollections = {`);
-  for (const collection of config.collections) {
-    const interfaceName = slugToPascalCase(collection.slug);
-    lines.push(
-      `  '${collection.slug}': { doc: ${interfaceName}; where: ${interfaceName}WhereClause };`
-    );
-  }
-  lines.push(`};`);
-  lines.push("");
-  lines.push(`/**`);
-  lines.push(` * Helper type for getting document type from collection slug.`);
-  lines.push(` */`);
-  lines.push(`export type DocumentType<S extends CollectionSlug> = MomentumCollections[S];`);
-  lines.push("");
-  lines.push(`/**`);
-  lines.push(` * Helper type for getting where clause type from collection slug.`);
-  lines.push(` */`);
-  lines.push(
-    `export type WhereClauseType<S extends CollectionSlug> = TypedMomentumCollections[S]['where'];`
-  );
-  lines.push("");
-  return lines.join("\n");
-}
-async function loadConfig(configPath) {
-  try {
-    const configUrl = (0, import_node_url.pathToFileURL)(configPath).href;
-    const configModule = await import(configUrl);
-    return configModule.default || configModule;
-  } catch (error) {
-    throw new Error(`Failed to load config from ${configPath}: ${error}`);
-  }
-}
-async function runExecutor(options, context) {
-  const projectRoot = context.projectsConfigurations?.projects[context.projectName ?? ""]?.root;
-  const root = projectRoot ? (0, import_node_path.join)(context.root, projectRoot) : context.root;
-  const configPath = (0, import_node_path.resolve)(root, options.configPath);
-  const outputPath = (0, import_node_path.resolve)(root, options.outputPath);
-  console.info(`Generating types from: ${configPath}`);
-  console.info(`Output to: ${outputPath}`);
-  async function generate() {
-    try {
-      const config = await loadConfig(configPath);
-      const types = generateTypes(config);
-      (0, import_node_fs.writeFileSync)(outputPath, types, "utf-8");
-      console.info(`Types generated successfully!`);
-    } catch (error) {
-      console.error(`Error generating types:`, error);
-      throw error;
-    }
-  }
-  await generate();
-  if (options.watch) {
-    console.info(`Watching for changes...`);
-    const configDir = (0, import_node_path.dirname)(configPath);
-    (0, import_node_fs.watch)(configDir, { recursive: true }, async (eventType, filename) => {
-      if (filename?.endsWith(".ts")) {
-        console.info(`Change detected: ${filename}`);
-        try {
-          await generate();
-        } catch {
-        }
-      }
-    });
-    return new Promise(() => {
-    });
-  }
-  return { success: true };
-}
-if (process.argv[1]?.endsWith("generator.ts") || process.argv[1]?.endsWith("generator.js") || process.argv[1]?.endsWith("generator.cjs")) {
-  const args = process.argv.slice(2);
-  const configPath = args[0];
-  const outputPath = args[1] || "src/types/momentum.generated.ts";
-  const watchMode = args.includes("--watch");
-  if (!configPath) {
-    console.error("Usage: npx ts-node generator.ts <config-path> [output-path] [--watch]");
-    process.exit(1);
-  }
-  runExecutor({ configPath, outputPath, watch: watchMode }, { root: process.cwd() }).then((result) => {
-    if (!result.success) {
-      process.exit(1);
-    }
-  }).catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
-}