@momentumcms/core 0.1.9 → 0.1.10

package/generators/types/generator.js

@@ -1,271 +0,0 @@
-// 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/src/generators/types/generator.d.ts

@@ -1,27 +0,0 @@
-/**
- * Momentum CMS Type Generator
- *
- * Generates TypeScript interfaces from collection definitions.
- * Run via: nx run <app>:generate-types
- */
-interface GeneratorSchema {
-    configPath: string;
-    outputPath: string;
-    watch?: boolean;
-}
-interface ExecutorContext {
-    root: string;
-    projectName?: string;
-    projectsConfigurations?: {
-        projects: Record<string, {
-            root: string;
-        }>;
-    };
-}
-/**
- * Main executor function.
- */
-export default function runExecutor(options: GeneratorSchema, context: ExecutorContext): Promise<{
-    success: boolean;
-}>;
-export {};