payload-live-preview 1.0.0

package/dist/codegen-astro.cjs

@@ -0,0 +1,612 @@
+'use strict';
+
+var fs = require('fs');
+var promises = require('fs/promises');
+var path = require('path');
+var tsMorph = require('ts-morph');
+
+// src/codegen/astro-plugin.ts
+var SCALAR_TYPE_MAP = {
+  text: "string",
+  textarea: "string",
+  email: "string",
+  richText: "unknown",
+  number: "number",
+  checkbox: "boolean",
+  date: "string",
+  code: "string",
+  point: "unknown",
+  ui: "unknown",
+  radio: "string"
+};
+function extractField(literal) {
+  const type = readStringProperty(literal, "type");
+  if (type === void 0) return void 0;
+  const STRUCTURAL_TYPES = /* @__PURE__ */ new Set(["tabs", "row", "collapsible"]);
+  const name = readStringProperty(literal, "name");
+  if (name === void 0 && !STRUCTURAL_TYPES.has(type)) return void 0;
+  const required = readBooleanProperty(literal, "required") ?? false;
+  const localized = readBooleanProperty(literal, "localized") ?? false;
+  const base = { name: name ?? "__structural", required, localized };
+  switch (type) {
+    case "array":
+      return {
+        ...base,
+        kind: "array",
+        fields: extractNestedFields(literal)
+      };
+    case "blocks":
+      return {
+        ...base,
+        kind: "blocks",
+        blocks: extractBlocks(literal)
+      };
+    case "group":
+      return {
+        ...base,
+        kind: "group",
+        fields: extractNestedFields(literal)
+      };
+    case "tabs":
+    case "row":
+    case "collapsible": {
+      const flattened = extractNestedFieldsFromStructural(literal);
+      return {
+        ...base,
+        kind: "group",
+        fields: flattened
+      };
+    }
+    case "relationship":
+      return {
+        ...base,
+        kind: "relationship",
+        target: readRelationTarget(literal),
+        hasMany: readBooleanProperty(literal, "hasMany") ?? false
+      };
+    case "upload":
+      return {
+        ...base,
+        kind: "upload",
+        target: readRelationTargetSingle(literal) ?? "media"
+      };
+    case "json":
+      return { ...base, kind: "json" };
+    case "select":
+      return {
+        ...base,
+        kind: "select",
+        options: readSelectOptions(literal),
+        hasMany: readBooleanProperty(literal, "hasMany") ?? false
+      };
+    default: {
+      const typeRef = SCALAR_TYPE_MAP[type] ?? "unknown";
+      return { ...base, kind: "scalar", typeRef };
+    }
+  }
+}
+function extractNestedFields(literal) {
+  const fieldsLiteral = readArrayProperty(literal, "fields");
+  if (!fieldsLiteral) return [];
+  const out = [];
+  for (const element of fieldsLiteral.getElements()) {
+    if (!tsMorph.Node.isObjectLiteralExpression(element)) continue;
+    const f = extractField(element);
+    if (!f) continue;
+    if (f.kind === "group" && f.name === "__structural") {
+      out.push(...f.fields);
+    } else {
+      out.push(f);
+    }
+  }
+  return out;
+}
+function extractNestedFieldsFromStructural(literal) {
+  const tabsLiteral = readArrayProperty(literal, "tabs");
+  if (tabsLiteral) {
+    const out = [];
+    for (const tabElement of tabsLiteral.getElements()) {
+      if (!tsMorph.Node.isObjectLiteralExpression(tabElement)) continue;
+      const tabName = readStringProperty(tabElement, "name");
+      const tabFields = extractNestedFields(tabElement);
+      if (tabName !== void 0) {
+        out.push({
+          kind: "group",
+          name: tabName,
+          required: false,
+          localized: false,
+          fields: tabFields
+        });
+      } else {
+        out.push(...tabFields);
+      }
+    }
+    return out;
+  }
+  return extractNestedFields(literal);
+}
+function extractBlocks(literal) {
+  const blocksLiteral = readArrayProperty(literal, "blocks");
+  if (!blocksLiteral) return [];
+  const out = [];
+  for (const element of blocksLiteral.getElements()) {
+    if (!tsMorph.Node.isObjectLiteralExpression(element)) continue;
+    const slug = readStringProperty(element, "slug");
+    if (slug === void 0) continue;
+    out.push({
+      slug,
+      typeName: toPascalCase(slug),
+      fields: extractNestedFields(element)
+    });
+  }
+  return out;
+}
+function readRelationTarget(literal) {
+  const property = literal.getProperty("relationTo");
+  if (!property || !tsMorph.Node.isPropertyAssignment(property)) return "unknown";
+  const initialiser = property.getInitializer();
+  if (initialiser && tsMorph.Node.isStringLiteral(initialiser)) return initialiser.getLiteralValue();
+  if (initialiser && tsMorph.Node.isArrayLiteralExpression(initialiser)) {
+    return initialiser.getElements().filter(tsMorph.Node.isStringLiteral).map((el) => el.getLiteralValue());
+  }
+  return "unknown";
+}
+function readRelationTargetSingle(literal) {
+  const target = readRelationTarget(literal);
+  if (typeof target === "string") return target;
+  return target[0];
+}
+function readSelectOptions(literal) {
+  const optionsLiteral = readArrayProperty(literal, "options");
+  if (!optionsLiteral) return [];
+  const out = [];
+  for (const element of optionsLiteral.getElements()) {
+    if (tsMorph.Node.isStringLiteral(element)) {
+      out.push(element.getLiteralValue());
+    } else if (tsMorph.Node.isObjectLiteralExpression(element)) {
+      const value = readStringProperty(element, "value");
+      if (value !== void 0) out.push(value);
+    }
+  }
+  return out;
+}
+function readStringProperty(literal, name) {
+  const property = literal.getProperty(name);
+  if (!property || !isPropertyAssignment(property)) return void 0;
+  const initialiser = property.getInitializer();
+  if (initialiser && tsMorph.Node.isStringLiteral(initialiser)) return initialiser.getLiteralValue();
+  if (initialiser && tsMorph.Node.isNoSubstitutionTemplateLiteral(initialiser)) {
+    return initialiser.getLiteralValue();
+  }
+  return void 0;
+}
+function readBooleanProperty(literal, name) {
+  const property = literal.getProperty(name);
+  if (!property || !isPropertyAssignment(property)) return void 0;
+  const initialiser = property.getInitializer();
+  if (!initialiser) return void 0;
+  if (initialiser.getKind() === tsMorph.SyntaxKind.TrueKeyword) return true;
+  if (initialiser.getKind() === tsMorph.SyntaxKind.FalseKeyword) return false;
+  return void 0;
+}
+function readArrayProperty(literal, name) {
+  const property = literal.getProperty(name);
+  if (!property || !isPropertyAssignment(property)) return void 0;
+  const initialiser = property.getInitializer();
+  if (initialiser && tsMorph.Node.isArrayLiteralExpression(initialiser)) return initialiser;
+  return void 0;
+}
+function isPropertyAssignment(node) {
+  return tsMorph.Node.isPropertyAssignment(node);
+}
+function toPascalCase(slug) {
+  return slug.split(/[-_\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+
+// src/codegen/parser/extract-schema.ts
+function extractSchema(options) {
+  const project = options.project ?? new tsMorph.Project(
+    options.tsConfigFilePath !== void 0 ? { tsConfigFilePath: options.tsConfigFilePath } : { skipAddingFilesFromTsConfig: true }
+  );
+  const sourceFile = project.addSourceFileAtPathIfExists(options.configPath);
+  if (!sourceFile) {
+    return {
+      globals: [],
+      collections: [],
+      diagnostics: [`Could not open ${options.configPath}`]
+    };
+  }
+  project.resolveSourceFileDependencies();
+  const diagnostics = [];
+  const configLiteral = findConfigLiteral(sourceFile, diagnostics);
+  if (!configLiteral) {
+    return {
+      globals: [],
+      collections: [],
+      diagnostics: [
+        ...diagnostics,
+        "Could not locate a buildConfig({...}) call or `export default {...}` in the config file."
+      ]
+    };
+  }
+  const globals = extractSlugList(configLiteral, "globals", diagnostics);
+  const collections = extractSlugList(configLiteral, "collections", diagnostics);
+  return { globals, collections, diagnostics };
+}
+function findConfigLiteral(sourceFile, diagnostics) {
+  const defaultExport = sourceFile.getExportSymbols().find((sym) => sym.getName() === "default");
+  if (!defaultExport) {
+    diagnostics.push("payload.config.ts has no default export.");
+    return void 0;
+  }
+  const declarations = defaultExport.getDeclarations();
+  for (const decl of declarations) {
+    const candidate = unwrapToObjectLiteral(decl);
+    if (candidate) return candidate;
+  }
+  for (const call of sourceFile.getDescendantsOfKind(tsMorph.SyntaxKind.CallExpression)) {
+    const expr = call.getExpression();
+    if (tsMorph.Node.isIdentifier(expr) && expr.getText() === "buildConfig") {
+      const arg = call.getArguments()[0];
+      if (arg && tsMorph.Node.isObjectLiteralExpression(arg)) return arg;
+    }
+  }
+  return void 0;
+}
+function unwrapToObjectLiteral(node) {
+  if (tsMorph.Node.isExportAssignment(node)) {
+    return unwrapExpression(node.getExpression());
+  }
+  if (tsMorph.Node.isVariableDeclaration(node)) {
+    const initialiser = node.getInitializer();
+    if (initialiser) return unwrapExpression(initialiser);
+  }
+  return void 0;
+}
+function unwrapExpression(node) {
+  if (!node) return void 0;
+  if (tsMorph.Node.isObjectLiteralExpression(node)) return node;
+  if (tsMorph.Node.isCallExpression(node)) {
+    const arg = node.getArguments()[0];
+    if (arg && tsMorph.Node.isObjectLiteralExpression(arg)) return arg;
+  }
+  if (tsMorph.Node.isAsExpression(node)) {
+    return unwrapExpression(node.getExpression());
+  }
+  if (tsMorph.Node.isSatisfiesExpression(node)) {
+    return unwrapExpression(node.getExpression());
+  }
+  if (tsMorph.Node.isIdentifier(node)) {
+    return resolveIdentifierToObjectLiteral(node);
+  }
+  return void 0;
+}
+function resolveIdentifierToObjectLiteral(identifier) {
+  for (const decl of identifier.getDefinitionNodes()) {
+    const result = unwrapToObjectLiteral(decl);
+    if (result) return result;
+  }
+  return void 0;
+}
+function extractSlugList(configLiteral, key, diagnostics) {
+  const property = configLiteral.getProperty(key);
+  if (!property) return [];
+  if (!tsMorph.Node.isPropertyAssignment(property)) return [];
+  const initialiser = property.getInitializer();
+  if (!initialiser) return [];
+  const array = resolveToArrayLiteral(initialiser);
+  if (!array) return [];
+  return extractEntries(array, diagnostics);
+}
+function extractEntries(array, diagnostics) {
+  const out = [];
+  for (const element of array.getElements()) {
+    if (tsMorph.Node.isSpreadElement(element)) {
+      const expandedArray = resolveToArrayLiteral(element.getExpression());
+      if (!expandedArray) {
+        diagnostics.push(
+          `Could not resolve spread "${element.getText().slice(0, 80)}" to an array literal.`
+        );
+        continue;
+      }
+      out.push(...extractEntries(expandedArray, diagnostics));
+      continue;
+    }
+    const literal = resolveToObjectLiteral(element);
+    if (!literal) {
+      diagnostics.push(
+        `Could not resolve config entry "${element.getText().slice(0, 80)}" to an object literal.`
+      );
+      continue;
+    }
+    const slug = readStringProperty2(literal, "slug");
+    if (slug === void 0) {
+      diagnostics.push(`Skipping a config entry \u2014 no string \`slug\` field found.`);
+      continue;
+    }
+    out.push({
+      slug,
+      typeName: toPascalCase(slug),
+      fields: extractFieldList(literal)
+    });
+  }
+  return out;
+}
+function extractFieldList(configEntry) {
+  const fieldsProperty = configEntry.getProperty("fields");
+  if (!fieldsProperty || !tsMorph.Node.isPropertyAssignment(fieldsProperty)) return [];
+  const initialiser = fieldsProperty.getInitializer();
+  if (!initialiser || !tsMorph.Node.isArrayLiteralExpression(initialiser)) return [];
+  const out = [];
+  for (const element of initialiser.getElements()) {
+    if (tsMorph.Node.isSpreadElement(element)) {
+      const expanded = resolveToArrayLiteral(element.getExpression());
+      if (!expanded) continue;
+      for (const inner of expanded.getElements()) {
+        const literal2 = resolveToObjectLiteral(inner);
+        if (!literal2) continue;
+        const field2 = extractField(literal2);
+        if (!field2) continue;
+        if (field2.kind === "group" && field2.name === "__structural") {
+          out.push(...field2.fields);
+        } else {
+          out.push(field2);
+        }
+      }
+      continue;
+    }
+    const literal = resolveToObjectLiteral(element);
+    if (!literal) continue;
+    const field = extractField(literal);
+    if (!field) continue;
+    if (field.kind === "group" && field.name === "__structural") {
+      out.push(...field.fields);
+    } else {
+      out.push(field);
+    }
+  }
+  return out;
+}
+function resolveToObjectLiteral(node) {
+  if (tsMorph.Node.isObjectLiteralExpression(node)) return node;
+  if (tsMorph.Node.isIdentifier(node)) return resolveIdentifierToObjectLiteral(node);
+  if (tsMorph.Node.isAsExpression(node)) return resolveToObjectLiteral(node.getExpression());
+  if (tsMorph.Node.isSatisfiesExpression(node)) return resolveToObjectLiteral(node.getExpression());
+  if (tsMorph.Node.isCallExpression(node)) {
+    const arg = node.getArguments()[0];
+    if (arg) return resolveToObjectLiteral(arg);
+  }
+  return void 0;
+}
+function resolveToArrayLiteral(node) {
+  if (tsMorph.Node.isArrayLiteralExpression(node)) return node;
+  if (tsMorph.Node.isAsExpression(node)) return resolveToArrayLiteral(node.getExpression());
+  if (tsMorph.Node.isSatisfiesExpression(node)) return resolveToArrayLiteral(node.getExpression());
+  if (tsMorph.Node.isIdentifier(node)) {
+    for (const decl of node.getDefinitionNodes()) {
+      if (tsMorph.Node.isVariableDeclaration(decl)) {
+        const initialiser = decl.getInitializer();
+        if (initialiser) {
+          const resolved = resolveToArrayLiteral(initialiser);
+          if (resolved) return resolved;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function readStringProperty2(literal, name) {
+  const property = literal.getProperty(name);
+  if (!property || !tsMorph.Node.isPropertyAssignment(property)) return void 0;
+  const initialiser = property.getInitializer();
+  if (initialiser && tsMorph.Node.isStringLiteral(initialiser)) return initialiser.getLiteralValue();
+  return void 0;
+}
+
+// src/codegen/emit/emit-types.ts
+var DEFAULT_HEADER = "// Auto-generated by payload-live-preview/codegen.\n// Do not edit by hand \u2014 run `pll-codegen` to regenerate.\n/* eslint-disable */";
+function emitTypes(schema, options = {}) {
+  const lines = [];
+  lines.push(options.header ?? DEFAULT_HEADER);
+  lines.push("");
+  lines.push('import type { PayloadMedia, PayloadRelationship } from "payload-live-preview";');
+  lines.push("");
+  const seenAuxNames = /* @__PURE__ */ new Set();
+  for (const slug of [...schema.globals, ...schema.collections]) {
+    emitSlug(slug, lines, seenAuxNames, options);
+    lines.push("");
+  }
+  if (schema.globals.length > 0) {
+    lines.push("export type PayloadGlobals = {");
+    for (const g of schema.globals) {
+      lines.push(`  '${g.slug}': ${g.typeName};`);
+    }
+    lines.push("};");
+    lines.push("");
+  }
+  if (schema.collections.length > 0) {
+    lines.push("export type PayloadCollections = {");
+    for (const c of schema.collections) {
+      lines.push(`  '${c.slug}': ${c.typeName};`);
+    }
+    lines.push("};");
+    lines.push("");
+  }
+  const slugAliases = [];
+  if (schema.globals.length > 0) slugAliases.push("keyof PayloadGlobals");
+  if (schema.collections.length > 0) slugAliases.push("keyof PayloadCollections");
+  if (slugAliases.length > 0) {
+    lines.push(`export type PayloadSlug = ${slugAliases.join(" | ")};`);
+    lines.push("");
+  }
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function emitSlug(slug, lines, seenAuxNames, options) {
+  emitAuxiliaries(slug.typeName, slug.fields, lines, seenAuxNames, options);
+  lines.push(`export interface ${slug.typeName} {`);
+  for (const field of slug.fields) {
+    emitFieldMember(field, slug.typeName, lines, options);
+  }
+  lines.push("}");
+}
+function emitAuxiliaries(prefix, fields, lines, seenAuxNames, options) {
+  for (const field of fields) {
+    const auxName = nestedTypeName(prefix, field.name);
+    if (field.kind === "array" || field.kind === "group") {
+      if (seenAuxNames.has(auxName)) continue;
+      seenAuxNames.add(auxName);
+      emitAuxiliaries(auxName, field.fields, lines, seenAuxNames, options);
+      lines.push(`export interface ${auxName} {`);
+      for (const inner of field.fields) {
+        emitFieldMember(inner, auxName, lines, options);
+      }
+      lines.push("}");
+      lines.push("");
+    } else if (field.kind === "blocks") {
+      for (const block of field.blocks) {
+        const blockTypeName = nestedTypeName(auxName, block.typeName);
+        if (seenAuxNames.has(blockTypeName)) continue;
+        seenAuxNames.add(blockTypeName);
+        emitAuxiliaries(blockTypeName, block.fields, lines, seenAuxNames, options);
+        emitBlockInterface(blockTypeName, block, lines, options);
+      }
+    }
+  }
+}
+function emitBlockInterface(typeName, block, lines, options) {
+  lines.push(`export interface ${typeName} {`);
+  lines.push(`  blockType: '${block.slug}';`);
+  for (const field of block.fields) {
+    emitFieldMember(field, typeName, lines, options);
+  }
+  lines.push("}");
+  lines.push("");
+}
+function emitFieldMember(field, parent, lines, options) {
+  if (options.markLocalizedAsDeprecated && field.localized) {
+    lines.push(`  /** @localized */`);
+  }
+  const optional = field.required ? "" : "?";
+  lines.push(`  ${field.name}${optional}: ${renderFieldType(field, parent)};`);
+}
+function renderFieldType(field, parent) {
+  switch (field.kind) {
+    case "scalar":
+      return field.typeRef;
+    case "array":
+      return `${nestedTypeName(parent, field.name)}[]`;
+    case "blocks": {
+      if (field.blocks.length === 0) return "unknown[]";
+      const variants = field.blocks.map((b) => nestedTypeName(nestedTypeName(parent, field.name), b.typeName)).join(" | ");
+      return `(${variants})[]`;
+    }
+    case "group":
+      return nestedTypeName(parent, field.name);
+    case "relationship": {
+      const targetExpr = Array.isArray(field.target) ? field.target.map((t) => `'${t}'`).join(" | ") : `'${field.target}'`;
+      const base = `PayloadRelationship<${targetExpr}>`;
+      return field.hasMany ? `${base}[]` : base;
+    }
+    case "upload":
+      return "PayloadMedia";
+    case "json":
+      return "unknown";
+    case "select": {
+      if (field.options.length === 0) return field.hasMany ? "string[]" : "string";
+      const literal = field.options.map((o) => `'${o}'`).join(" | ");
+      return field.hasMany ? `(${literal})[]` : literal;
+    }
+  }
+}
+function nestedTypeName(parent, child) {
+  return `${parent}${toPascalCase(child)}`;
+}
+
+// src/codegen/index.ts
+async function generateTypes(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = path.isAbsolute(options.configPath) ? options.configPath : path.resolve(cwd, options.configPath);
+  const schema = extractSchema({
+    configPath,
+    ...options.project !== void 0 ? { project: options.project } : {},
+    ...options.tsConfigFilePath !== void 0 ? { tsConfigFilePath: options.tsConfigFilePath } : {}
+  });
+  const code = emitTypes(schema, options);
+  const result = options.outFile ? {
+    code,
+    diagnostics: schema.diagnostics,
+    schema,
+    outFile: path.isAbsolute(options.outFile) ? options.outFile : path.resolve(cwd, options.outFile)
+  } : { code, diagnostics: schema.diagnostics, schema };
+  if (result.outFile) {
+    await promises.mkdir(path.dirname(result.outFile), { recursive: true });
+    await promises.writeFile(result.outFile, code, "utf8");
+  }
+  return result;
+}
+
+// src/codegen/astro-plugin.ts
+function livePreviewCodegen(options) {
+  const watchEnabled = options.watch ?? true;
+  let watcher;
+  let active = false;
+  let queued = false;
+  async function regenerate(logger) {
+    if (active) {
+      queued = true;
+      return;
+    }
+    active = true;
+    try {
+      const result = await generateTypes({
+        configPath: options.configPath,
+        outFile: options.outPath
+      });
+      if (!options.quiet) {
+        logger?.info(
+          `pll-codegen: ${result.schema.globals.length} globals, ${result.schema.collections.length} collections \u2192 ${options.outPath}`
+        );
+        for (const diagnostic of result.diagnostics) {
+          logger?.warn(`pll-codegen: ${diagnostic}`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger?.error(`pll-codegen failed: ${message}`);
+    } finally {
+      active = false;
+      if (queued) {
+        queued = false;
+        void regenerate(logger);
+      }
+    }
+  }
+  return {
+    name: "payload-live-preview:codegen",
+    hooks: {
+      "astro:config:setup": async ({ command, logger }) => {
+        await regenerate(logger);
+        if (watchEnabled && command === "dev") {
+          try {
+            watcher = fs.watch(options.configPath, () => {
+              void regenerate(logger);
+            });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger?.warn(`pll-codegen watcher unavailable: ${message}`);
+          }
+        }
+      },
+      "astro:server:start": () => {
+      },
+      "astro:build:start": () => {
+        watcher?.close();
+        watcher = void 0;
+      }
+    }
+  };
+}
+
+exports.livePreviewCodegen = livePreviewCodegen;
+//# sourceMappingURL=codegen-astro.cjs.map
+//# sourceMappingURL=codegen-astro.cjs.map