@blinkk/root-cms 2.4.9 → 2.5.1

package/dist/chunk-RIJF2AHU.js

@@ -0,0 +1,136 @@
+import {
+  RootCMSClient,
+  getCmsPlugin
+} from "./chunk-NUUABQRN.js";
+
+// core/versions.ts
+import path from "path";
+import { Timestamp } from "firebase-admin/firestore";
+import glob from "tiny-glob";
+var DOCUMENT_SAVE_OFFSET = 5 * 60 * 1e3;
+var VersionsService = class {
+  constructor(rootConfig) {
+    this.rootConfig = rootConfig;
+    const cmsPlugin = getCmsPlugin(rootConfig);
+    const cmsPluginOptions = cmsPlugin.getConfig();
+    const projectId = cmsPluginOptions.id || "default";
+    this.projectId = projectId;
+    this.db = cmsPlugin.getFirestore();
+  }
+  /**
+   * Saves a version of all documents that have been edited since the last run.
+   */
+  async saveVersions() {
+    const lastRun = await this.getLastRun();
+    const lastRunWithOffset = lastRun === 0 ? lastRun : lastRun - DOCUMENT_SAVE_OFFSET;
+    const changedDocs = await this.getDocsModifiedAfter(lastRunWithOffset);
+    const now = Timestamp.now().toMillis();
+    const versions = changedDocs.filter((doc) => {
+      const modifiedAt = doc.sys.modifiedAt.toMillis();
+      return modifiedAt <= now - DOCUMENT_SAVE_OFFSET;
+    });
+    if (versions.length > 0) {
+      this.saveVersionsToFirestore(versions);
+    }
+    this.saveLastRun(now);
+  }
+  async saveVersionsToFirestore(versions) {
+    const batch = this.db.batch();
+    versions.forEach((version) => {
+      if (!version.collection || !version.slug || !version.sys?.modifiedAt) {
+        return;
+      }
+      const modifiedAtMillis = version.sys.modifiedAt.toMillis();
+      const versionPath = `Projects/${this.projectId}/Collections/${version.collection}/Drafts/${version.slug}/Versions/${modifiedAtMillis}`;
+      console.log(versionPath);
+      const versionRef = this.db.doc(versionPath);
+      batch.set(versionRef, version);
+    });
+    await batch.commit();
+    console.log(`versions: saved ${versions.length} versions`);
+  }
+  /**
+   * Returns the last time (in millis) saveVersions() was run, or 0 if has
+   * never been run.
+   */
+  async getLastRun() {
+    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
+    const projectDoc = await projectDocRef.get();
+    if (projectDoc.exists) {
+      const data = projectDoc.data() || {};
+      const ts = data.versionsLastRun;
+      if (ts) {
+        return ts.toMillis();
+      }
+    }
+    return 0;
+  }
+  /**
+   * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.
+   */
+  async saveLastRun(millis) {
+    const ts = Timestamp.fromMillis(millis);
+    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
+    await projectDocRef.set({ versionsLastRun: ts }, { merge: true });
+  }
+  /**
+   * Returns a list of all docs that were edited after a certain time.
+   */
+  async getDocsModifiedAfter(millis) {
+    const ts = Timestamp.fromMillis(millis);
+    const results = [];
+    const collectionIds = await this.listCollections();
+    for (const collectionId of collectionIds) {
+      const collectionPath = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const query = this.db.collection(collectionPath).where("sys.modifiedAt", ">=", ts);
+      const querySnapshot = await query.get();
+      querySnapshot.forEach((doc) => {
+        results.push(doc.data());
+      });
+    }
+    return results;
+  }
+  /**
+   * Returns a list of collection ids for the Root project.
+   */
+  async listCollections() {
+    const collectionIds = [];
+    const collectionFileNames = await glob("*.schema.ts", {
+      cwd: path.join(this.rootConfig.rootDir, "collections")
+    });
+    collectionFileNames.forEach((filename) => {
+      collectionIds.push(filename.slice(0, -10));
+    });
+    return collectionIds;
+  }
+};
+
+// core/cron.ts
+async function runCronJobs(rootConfig) {
+  await Promise.all([
+    runCronJob("publishScheduledDocs", runPublishScheduledDocs, rootConfig),
+    runCronJob("saveVersions", runSaveVersions, rootConfig)
+  ]);
+}
+async function runCronJob(name, fn, ...args) {
+  try {
+    await fn(...args);
+  } catch (err) {
+    console.log(`cron failed: ${name}`);
+    console.error(String(err.stack || err));
+    throw err;
+  }
+}
+async function runPublishScheduledDocs(rootConfig) {
+  const cmsClient = new RootCMSClient(rootConfig);
+  await cmsClient.publishScheduledDocs();
+  await cmsClient.publishScheduledReleases();
+}
+async function runSaveVersions(rootConfig) {
+  const service = new VersionsService(rootConfig);
+  await service.saveVersions();
+}
+
+export {
+  runCronJobs
+};

package/dist/chunk-RNDSZKAW.js

@@ -0,0 +1,171 @@
+// core/project.ts
+var SCHEMA_MODULES = import.meta.glob(
+  [
+    "/**/*.schema.ts",
+    "!/appengine/**/*.schema.ts",
+    "!/functions/**/*.schema.ts",
+    "!/gae/**/*.schema.ts"
+  ],
+  { eager: true }
+);
+async function getProjectSchemas() {
+  const schemas = {};
+  for (const fileId in SCHEMA_MODULES) {
+    const schemaModule = SCHEMA_MODULES[fileId];
+    if (schemaModule.default) {
+      const resolved = resolveOneOfPatterns(schemaModule.default);
+      schemas[fileId] = resolved;
+    }
+  }
+  return schemas;
+}
+function resolveOneOfPatterns(schemaObj) {
+  const clone = structuredClone(schemaObj);
+  function handleField(field) {
+    if (field.type === "oneof") {
+      const oneOfField = field;
+      if (isSchemaPattern(oneOfField.types)) {
+        const resolved = resolveSchemaPattern(oneOfField.types);
+        oneOfField.types = resolved.names.map((name) => resolved.schemas[name]);
+      }
+    } else if (field.type === "object" && "fields" in field) {
+      (field.fields || []).forEach(handleField);
+    } else if (field.type === "array" && "of" in field && field.of) {
+      handleField(field.of);
+    }
+  }
+  (clone.fields || []).forEach(handleField);
+  return clone;
+}
+async function getCollectionSchema(collectionId) {
+  if (!testValidCollectionId(collectionId)) {
+    throw new Error(`invalid collection id: ${collectionId}`);
+  }
+  const fileId = `/collections/${collectionId}.schema.ts`;
+  const module = SCHEMA_MODULES[fileId];
+  if (!module.default) {
+    console.warn(`collection schema not exported in: ${fileId}`);
+    return null;
+  }
+  const collection = module.default;
+  collection.id = collectionId;
+  return convertOneOfTypes(collection);
+}
+function testValidCollectionId(id) {
+  return /^[A-Za-z0-9_-]+$/.test(id);
+}
+function isSchemaPattern(value) {
+  return typeof value === "object" && value !== null && "_schemaPattern" in value && value._schemaPattern === true;
+}
+function buildSchemaNameMap() {
+  const nameMap = {};
+  for (const fileId in SCHEMA_MODULES) {
+    const module = SCHEMA_MODULES[fileId];
+    if (module.default && module.default.name) {
+      nameMap[module.default.name] = module.default;
+    }
+  }
+  return nameMap;
+}
+function globToRegex(pattern) {
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/\{\{DOUBLE_STAR\}\}/g, ".*");
+  return new RegExp(`^${regexStr}$`);
+}
+function resolveSchemaPattern(pattern) {
+  const regex = globToRegex(pattern.pattern);
+  const excludeSet = new Set(pattern.exclude || []);
+  const names = [];
+  const schemas = {};
+  for (const fileId in SCHEMA_MODULES) {
+    if (!regex.test(fileId)) {
+      continue;
+    }
+    const module = SCHEMA_MODULES[fileId];
+    if (!module.default || !module.default.name) {
+      continue;
+    }
+    const schemaName = module.default.name;
+    if (excludeSet.has(schemaName)) {
+      continue;
+    }
+    let schemaObj = module.default;
+    if (pattern.omitFields && pattern.omitFields.length > 0) {
+      const omitSet = new Set(pattern.omitFields);
+      schemaObj = {
+        ...schemaObj,
+        fields: schemaObj.fields.filter(
+          (f) => !omitSet.has(f.id || "")
+        )
+      };
+    }
+    names.push(schemaName);
+    schemas[schemaName] = schemaObj;
+  }
+  return { names, schemas };
+}
+function convertOneOfTypes(collection) {
+  const clone = structuredClone(collection);
+  const types = clone.types || {};
+  const schemaNameMap = buildSchemaNameMap();
+  function handleOneOfField(field) {
+    if (isSchemaPattern(field.types)) {
+      const resolved = resolveSchemaPattern(field.types);
+      for (const [name, schemaObj] of Object.entries(resolved.schemas)) {
+        if (!types[name]) {
+          types[name] = schemaObj;
+          if (schemaObj.fields) {
+            walk(schemaObj);
+          }
+        }
+      }
+      field.types = resolved.names;
+      return;
+    }
+    const names = [];
+    (field.types || []).forEach((sub) => {
+      if (typeof sub === "string") {
+        names.push(sub);
+        if (!types[sub] && schemaNameMap[sub]) {
+          const resolvedSchema = schemaNameMap[sub];
+          types[sub] = resolvedSchema;
+          if (resolvedSchema.fields) {
+            walk(resolvedSchema);
+          }
+        }
+        return;
+      }
+      if (sub.name) {
+        names.push(sub.name);
+        if (!types[sub.name]) {
+          types[sub.name] = sub;
+          if (sub.fields) {
+            walk(sub);
+          }
+        }
+      }
+    });
+    field.types = names;
+  }
+  function handleField(field) {
+    if (field.type === "oneof") {
+      handleOneOfField(field);
+    } else if (field.type === "object") {
+      walk(field);
+    } else if (field.type === "array" && field.of) {
+      handleField(field.of);
+    }
+  }
+  function walk(schema) {
+    const fields = schema?.fields || [];
+    fields.forEach(handleField);
+  }
+  walk(clone);
+  clone.types = types;
+  return clone;
+}
+
+export {
+  SCHEMA_MODULES,
+  getProjectSchemas,
+  getCollectionSchema
+};

package/dist/chunk-RYF3UTHQ.js

@@ -0,0 +1,302 @@
+// cli/generate-types.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { loadRootConfig, viteSsrLoadModule } from "@blinkk/root/node";
+import * as dom from "dts-dom";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+async function generateTypes() {
+  const rootDir = process.cwd();
+  const rootConfig = await loadRootConfig(rootDir, { command: "root-cms" });
+  const modulePath = path.resolve(__dirname, "./project.js");
+  const project = await viteSsrLoadModule(
+    rootConfig,
+    modulePath
+  );
+  const schemas = await project.getProjectSchemas();
+  const outputPath = path.resolve(rootDir, "root-cms.d.ts");
+  await generateSchemaDts(outputPath, schemas);
+  console.log("saved root-cms.d.ts!");
+}
+var TEMPLATE = `/* eslint-disable */
+/** Root.js CMS types. This file is autogenerated. */
+
+export interface RootCMSFile {
+  src: string;
+  width?: number;
+  height?: number;
+  alt?: string;
+}
+
+export type RootCMSImage = RootCMSFile;
+
+export type RootCMSOneOf<T = any> = T;
+
+export type RootCMSOneOfOption<T, Base> = Base & {_type: T};
+
+export interface RootCMSRichTextBlock {
+  type: string;
+  data: any;
+}
+
+export interface RootCMSRichText {
+  blocks: RootCMSRichTextBlock[];
+}
+
+export interface RootCMSReference {
+  /** The id of the doc, e.g. "Pages/foo-bar". */
+  id: string;
+  /** The collection id of the doc, e.g. "Pages". */
+  collection: string;
+  /** The slug of the doc, e.g. "foo-bar". */
+  slug: string;
+}
+
+export interface RootCMSDoc<Fields extends {}> {
+  /** The id of the doc, e.g. "Pages/foo-bar". */
+  id: string;
+  /** The collection id of the doc, e.g. "Pages". */
+  collection: string;
+  /** The slug of the doc, e.g. "foo-bar". */
+  slug: string;
+  /** System-level metadata. */
+  sys: {
+    createdAt: number;
+    createdBy: string;
+    modifiedAt: number;
+    modifiedBy: string;
+    firstPublishedAt?: number;
+    firstPublishedBy?: string;
+    publishedAt?: number;
+    publishedBy?: string;
+    locales?: string[];
+  };
+  /** User-entered field values from the CMS. */
+  fields?: Fields;
+}`;
+var DtsFormatter = class {
+  constructor() {
+    /**
+     * Field types defined in either `.schema.ts` files or used by `oneOf()`
+     * fields.
+     */
+    this.fieldsTypes = {};
+    /**
+     * For `collections/*.schema.ts` files, output a corresponding "RootCMSDoc"
+     * type. For example, `collections/BlogPosts.schema.ts` would output a type
+     * called `BlogPostsDoc`.
+     */
+    this.docTypes = {};
+  }
+  /** Adds the types for a `.schema.ts` file to the `.d.ts` file. */
+  addSchemaFile(fileId, schema) {
+    const jsdoc = `Generated from \`${fileId}\`.`;
+    const typeId = alphanumeric(path.parse(fileId).name.split(".")[0]);
+    const oneOfTypes = {};
+    const fieldsTypeId = `${typeId}Fields`;
+    const fieldsType = dom.create.interface(
+      fieldsTypeId,
+      dom.DeclarationFlags.Export
+    );
+    fieldsType.jsDocComment = jsdoc;
+    for (const field of schema.fields) {
+      if (!field.id) {
+        continue;
+      }
+      fieldsType.members.push(fieldProperty(field, { typeId, oneOfTypes }));
+    }
+    for (const oneOfTypeId in oneOfTypes) {
+      if (!this.fieldsTypes[fieldsTypeId]) {
+        this.fieldsTypes[oneOfTypeId] = oneOfTypes[oneOfTypeId];
+      }
+    }
+    this.fieldsTypes[fieldsTypeId] = fieldsType;
+    if (fileId.startsWith("/collections/")) {
+      const docTypeId = `${typeId}Doc`;
+      const baseType = dom.create.namedTypeReference("RootCMSDoc");
+      baseType.typeArguments.push(dom.create.namedTypeReference(fieldsTypeId));
+      const docType = dom.create.alias(
+        docTypeId,
+        baseType,
+        dom.DeclarationFlags.Export
+      );
+      docType.jsDocComment = jsdoc;
+      this.docTypes[docTypeId] = docType;
+    }
+  }
+  /** Generates the `.d.ts` output as a string. */
+  toString() {
+    const results = [TEMPLATE];
+    const sortedFieldsTypes = Object.keys(this.fieldsTypes).sort();
+    for (const fieldsTypeId of sortedFieldsTypes) {
+      const fieldsType = this.fieldsTypes[fieldsTypeId];
+      results.push(this.typeToString(fieldsType));
+      const docTypeId = this.fieldsTypeToDocType(fieldsTypeId);
+      const docType = this.docTypes[docTypeId];
+      if (docType) {
+        results.push(this.typeToString(docType));
+      }
+    }
+    const output = results.join("\n\n").replaceAll("/**  ", "/** ").replaceAll("  */", " */").replace(/\r\n|\r|\n/g, "\n") + "\n";
+    return output;
+  }
+  /**
+   * Converts "<Name>Fields" to "<Name>Doc".
+   */
+  fieldsTypeToDocType(fieldsTypeId) {
+    if (!fieldsTypeId.endsWith("Fields")) {
+      throw new Error(`"${fieldsTypeId}" should be suffixed with "Fields"`);
+    }
+    const name = fieldsTypeId.slice(0, -6);
+    return `${name}Doc`;
+  }
+  typeToString(type2) {
+    return this.reformatOutput(dom.emit(type2, { singleLineJsDocComments: true }));
+  }
+  /**
+   * Formats the output to Google style conventions, e.g. 2-space indents and
+   * single quote strings.
+   */
+  reformatOutput(input) {
+    const lines = input.trim().split("\n");
+    const results = [];
+    for (const line of lines) {
+      const convertedLine = line.replace(/ {4}/g, "  ").replaceAll('"', "'");
+      results.push(convertedLine);
+    }
+    return results.join("\n");
+  }
+};
+async function generateSchemaDts(outputPath, schemas) {
+  const dtsFormatter = new DtsFormatter();
+  for (const fileId in schemas) {
+    const schema = schemas[fileId];
+    dtsFormatter.addSchemaFile(fileId, schema);
+  }
+  const output = dtsFormatter.toString();
+  await fs.writeFile(outputPath, output, "utf-8");
+}
+function fieldProperty(field, options) {
+  const prop = dom.create.property(
+    field.id,
+    fieldType(field, options),
+    dom.DeclarationFlags.Optional
+  );
+  const jsdoc = [];
+  if (field.label) {
+    if (field.help) {
+      jsdoc.push(`${field.label}. ${field.help}`);
+    } else {
+      jsdoc.push(field.label);
+    }
+  }
+  if (field.deprecated) {
+    jsdoc.push("@deprecated");
+  }
+  if (jsdoc.length > 0) {
+    prop.jsDocComment = jsdoc.join("\n");
+  }
+  return prop;
+}
+function fieldType(field, options) {
+  if (field.type === "array") {
+    return dom.type.array(fieldType(field.of, options));
+  }
+  if (field.type === "boolean") {
+    return dom.type.boolean;
+  }
+  if (field.type === "date") {
+    return dom.type.string;
+  }
+  if (field.type === "datetime") {
+    return dom.type.number;
+  }
+  if (field.type === "file") {
+    const fileType = dom.create.namedTypeReference("RootCMSFile");
+    return fileType;
+  }
+  if (field.type === "image") {
+    const imageType = dom.create.namedTypeReference("RootCMSImage");
+    return imageType;
+  }
+  if (field.type === "multiselect") {
+    return dom.type.array(dom.type.string);
+  }
+  if (field.type === "oneof") {
+    const oneOf = dom.create.namedTypeReference("RootCMSOneOf");
+    if (field.types && Array.isArray(field.types)) {
+      const unionTypes = [];
+      field.types.forEach((schema) => {
+        let typeName;
+        if (typeof schema === "string") {
+          typeName = schema;
+          return;
+        } else {
+          typeName = schema.name;
+        }
+        if (!typeName) {
+          return;
+        }
+        const cleanName = alphanumeric(typeName);
+        const oneOfTypeId = `${cleanName}Fields`;
+        if (typeof schema === "object" && !options.oneOfTypes[oneOfTypeId]) {
+          const oneOfTypeInterface = dom.create.interface(
+            oneOfTypeId,
+            dom.DeclarationFlags.Export
+          );
+          if (schema.description) {
+            oneOfTypeInterface.jsDocComment = schema.description;
+          }
+          const oneOfTypeFields = schema.fields || [];
+          oneOfTypeFields.forEach((f) => {
+            oneOfTypeInterface.members.push(fieldProperty(f, options));
+          });
+          options.oneOfTypes[oneOfTypeId] = oneOfTypeInterface;
+        }
+        const oneOfOption = dom.create.namedTypeReference("RootCMSOneOfOption");
+        oneOfOption.typeArguments = [
+          dom.type.stringLiteral(typeName),
+          dom.create.namedTypeReference(oneOfTypeId)
+        ];
+        unionTypes.push(oneOfOption);
+      });
+      if (unionTypes.length > 0) {
+        oneOf.typeArguments = [dom.create.union(unionTypes)];
+      }
+    }
+    return oneOf;
+  }
+  if (field.type === "reference") {
+    const referenceType = dom.create.namedTypeReference("RootCMSReference");
+    return referenceType;
+  }
+  if (field.type === "references") {
+    const referenceType = dom.create.namedTypeReference("RootCMSReference");
+    return dom.type.array(referenceType);
+  }
+  if (field.type === "richtext") {
+    const richtextType = dom.create.namedTypeReference("RootCMSRichText");
+    return richtextType;
+  }
+  if (field.type === "select") {
+    return dom.type.string;
+  }
+  if (field.type === "string") {
+    return dom.type.string;
+  }
+  if (field.type === "object") {
+    const subproperties = (field.fields || []).map(
+      (f) => fieldProperty(f, options)
+    );
+    return dom.create.objectType(subproperties);
+  }
+  return dom.type.unknown;
+}
+function alphanumeric(input) {
+  return input.replace(/[^a-zA-Z0-9]/g, "");
+}
+
+export {
+  generateTypes,
+  generateSchemaDts
+};