@momentumcms/core 0.1.4 → 0.1.5

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.1.5 (2026-02-16)
+
+### 🚀 Features
+
+- **create-app:** add landing page, fix setup flow, theme detection, type generator, Playwright E2E ([5e0f4ed](https://github.com/DonaldMurillo/momentum-cms/commit/5e0f4ed))
+
+### ❤️ Thank You
+
+- Claude Opus 4.6
+- Donald Murillo @DonaldMurillo
+
 ## 0.1.4 (2026-02-16)
 
 This was a version bump only for core to align it with other projects, there were no code changes.

package/generators/types/generator.cjs

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

package/generators/types/generator.js

@@ -0,0 +1,271 @@
+// libs/core/src/generators/types/generator.ts
+import { writeFileSync, watch } from "node:fs";
+import { dirname, resolve, join } from "node:path";
+import { pathToFileURL } from "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 = 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 ? join(context.root, projectRoot) : context.root;
+  const configPath = resolve(root, options.configPath);
+  const outputPath = 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);
+      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 = dirname(configPath);
+    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);
+  });
+}
+export {
+  runExecutor as default
+};

package/package.json

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