@blinkk/root-cms 2.0.9 → 2.1.1

package/dist/app.js

@@ -7,7 +7,7 @@ import { render as renderToString } from "preact-render-to-string";
 // package.json
 var package_default = {
   name: "@blinkk/root-cms",
-  version: "2.0.9",
+  version: "2.1.1",
   author: "s@blinkk.com",
   license: "MIT",
   engines: {
@@ -154,7 +154,7 @@ var package_default = {
     yjs: "13.6.27"
   },
   peerDependencies: {
-    "@blinkk/root": "2.0.9",
+    "@blinkk/root": "2.1.1",
     "firebase-admin": ">=11",
     "firebase-functions": ">=4",
     preact: ">=10",
@@ -168,16 +168,18 @@ var package_default = {
 };
 
 // core/project.ts
-var IGNORED_SCHEMA_FOLDERS = ["/appengine/", "/functions/", "/gae/"];
-var SCHEMA_MODULES = import.meta.glob("/**/*.schema.ts", {
-  eager: true
-});
-function getProjectSchemas() {
+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) {
-    if (IGNORED_SCHEMA_FOLDERS.some((prefix) => fileId.startsWith(prefix))) {
-      continue;
-    }
     const schemaModule = SCHEMA_MODULES[fileId];
     if (schemaModule.default) {
       schemas[fileId] = schemaModule.default;
@@ -185,6 +187,62 @@ function getProjectSchemas() {
   }
   return schemas;
 }
+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 convertOneOfTypes(collection) {
+  const clone = structuredClone(collection);
+  const types = clone.types || {};
+  function handleOneOfField(field) {
+    const names = [];
+    (field.types || []).forEach((sub) => {
+      if (typeof sub === "string") {
+        names.push(sub);
+        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;
+}
 
 // core/app.tsx
 import { jsx, jsxs } from "preact/jsx-runtime";
@@ -259,9 +317,11 @@ function App(props) {
 }
 async function renderApp(req, res, options) {
   const collections = {};
-  Object.entries(getCollections()).forEach(([collectionId, collection]) => {
-    collections[collectionId] = serializeCollection(collection);
-  });
+  Object.entries(await getCollections()).forEach(
+    ([collectionId, collection]) => {
+      collections[collectionId] = serializeCollection(collection);
+    }
+  );
   const rootConfig = options.rootConfig || {};
   const cmsConfig = options.cmsConfig || {};
   let gci = cmsConfig.gci;
@@ -324,7 +384,8 @@ function serializeCollection(collection) {
     preview: collection.preview,
     slugRegex: collection.slugRegex,
     autolock: collection.autolock,
-    autolockReason: collection.autolockReason
+    autolockReason: collection.autolockReason,
+    sortOptions: collection.sortOptions
   };
 }
 function SignIn(props) {
@@ -407,18 +468,21 @@ ${mainHtml}`;
   res.status(403);
   res.send(html);
 }
-function getCollections() {
+async function getCollections() {
   const collections = {};
-  const schemas = getProjectSchemas();
+  const schemas = await getProjectSchemas();
   Object.entries(schemas).forEach(([fileId, schema]) => {
     if (fileId.startsWith("/collections/")) {
-      const collectionId = parseCollectionId(fileId);
-      collections[collectionId] = { ...schema, id: collectionId };
+      const collectionId = toCollectionId(fileId);
+      collections[collectionId] = { id: collectionId, ...schema };
     }
   });
   return collections;
 }
-function parseCollectionId(fileId) {
+async function getCollection(collectionId) {
+  return getCollectionSchema(collectionId);
+}
+function toCollectionId(fileId) {
   return path.basename(fileId).split(".")[0];
 }
 function generateNonce() {
@@ -461,6 +525,7 @@ function cachebust(req, url) {
   return `${url}?c=${value}`;
 }
 export {
+  getCollection,
   getCollections,
   renderApp,
   renderSignIn

package/dist/cli.js

@@ -17,7 +17,7 @@ async function generateTypes() {
     rootConfig,
     modulePath
   );
-  const schemas = project.getProjectSchemas();
+  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!");
@@ -231,12 +231,19 @@ function fieldType(field, options) {
     if (field.types && Array.isArray(field.types)) {
       const unionTypes = [];
       field.types.forEach((schema) => {
-        if (!schema.name) {
+        let typeName;
+        if (typeof schema === "string") {
+          typeName = schema;
           return;
+        } else {
+          typeName = schema.name;
         }
-        const cleanName = alphanumeric(schema.name);
+        if (!typeName) {
+          return;
+        }
+        const cleanName = alphanumeric(typeName);
         const oneOfTypeId = `${cleanName}Fields`;
-        if (!options.oneOfTypes[oneOfTypeId]) {
+        if (typeof schema === "object" && !options.oneOfTypes[oneOfTypeId]) {
           const oneOfTypeInterface = dom.create.interface(
             oneOfTypeId,
             dom.DeclarationFlags.Export
@@ -252,7 +259,7 @@ function fieldType(field, options) {
         }
         const oneOfOption = dom.create.namedTypeReference("RootCMSOneOfOption");
         oneOfOption.typeArguments = [
-          dom.type.stringLiteral(schema.name),
+          dom.type.stringLiteral(typeName),
           dom.create.namedTypeReference(oneOfTypeId)
         ];
         unionTypes.push(oneOfOption);
@@ -267,6 +274,10 @@ function fieldType(field, options) {
     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;

package/dist/core.d.ts

@@ -2,9 +2,8 @@ import { L as LoadTranslationsOptions, T as TranslationsMap, a as LocaleTranslat
 export { A as Action, p as ArrayObject, z as BatchRequest, B as BatchRequestOptions, w as BatchRequestQuery, x as BatchRequestQueryOptions, C as BatchResponse, c as DataSource, d as DataSourceData, e as DataSourceMode, D as Doc, b as DocMode, h as GetCountOptions, G as GetDocOptions, H as HttpMethod, j as ListActionsOptions, g as ListDocsOptions, E as Locale, N as MultiLocaleTranslationsMap, R as Release, k as RootCMSClient, f as SaveDraftOptions, S as SetDocOptions, O as SingleLocaleTranslationsMap, F as SourceString, I as TranslatedString, i as Translation, y as TranslationsDoc, J as TranslationsDocMode, M as TranslationsLocaleDocEntry, K as TranslationsLocaleDocHashMap, P as TranslationsManager, U as UserRole, Q as buildTranslationsDbPath, V as buildTranslationsLocaleDocDbPath, m as getCmsPlugin, l as isRichTextData, q as marshalArray, n as marshalData, o as normalizeData, v as parseDocId, t as toArrayObject, s as translationsForLocale, r as unmarshalArray, u as unmarshalData } from './client-Vr32ZRmC.js';
 import { RootConfig } from '@blinkk/root';
 import { Query } from 'firebase-admin/firestore';
-export { s as schema } from './schema-KpQGOA1Z.js';
+export { s as schema } from './schema-UCmjggdA.js';
 import 'firebase-admin/app';
-import 'preact';
 
 /** @deprecated Use client.ts instead. */
 

package/dist/core.js

@@ -1700,51 +1700,55 @@ __export(schema_exports, {
   object: () => object,
   oneOf: () => oneOf,
   reference: () => reference,
+  references: () => references,
   richtext: () => richtext,
   select: () => select,
   string: () => string
 });
 function string(field) {
-  return { ...field, type: "string" };
+  return { type: "string", ...field };
 }
 function number(field) {
-  return { ...field, type: "number" };
+  return { type: "number", ...field };
 }
 function date(field) {
-  return { ...field, type: "date" };
+  return { type: "date", ...field };
 }
 function datetime(field) {
-  return { ...field, type: "datetime" };
+  return { type: "datetime", ...field };
 }
 function boolean(field) {
-  return { ...field, type: "boolean" };
+  return { type: "boolean", ...field };
 }
 function select(field) {
-  return { ...field, type: "select" };
+  return { type: "select", ...field };
 }
 function multiselect(field) {
-  return { ...field, type: "multiselect" };
+  return { type: "multiselect", ...field };
 }
 function image(field) {
-  return { ...field, type: "image" };
+  return { type: "image", ...field };
 }
 function file(field) {
-  return { ...field, type: "file" };
+  return { type: "file", ...field };
 }
 function object(field) {
-  return { ...field, type: "object" };
+  return { type: "object", ...field };
 }
 function array(field) {
-  return { ...field, type: "array" };
+  return { type: "array", ...field };
 }
 function oneOf(field) {
-  return { ...field, type: "oneof" };
+  return { type: "oneof", ...field };
 }
 function richtext(field) {
-  return { ...field, type: "richtext" };
+  return { type: "richtext", ...field };
 }
 function reference(field) {
-  return { ...field, type: "reference" };
+  return { type: "reference", ...field };
+}
+function references(field) {
+  return { ...field, type: "references" };
 }
 function defineSchema(schema) {
   return schema;

package/dist/plugin.js

@@ -51,21 +51,21 @@ __export(generate_types_exports, {
   generateSchemaDts: () => generateSchemaDts,
   generateTypes: () => generateTypes
 });
-import { promises as fs2 } from "node:fs";
-import path3 from "node:path";
+import { promises as fs3 } from "node:fs";
+import path4 from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadRootConfig, viteSsrLoadModule } from "@blinkk/root/node";
 import * as dom from "dts-dom";
 async function generateTypes() {
   const rootDir = process.cwd();
   const rootConfig = await loadRootConfig(rootDir, { command: "root-cms" });
-  const modulePath = path3.resolve(__dirname, "./project.js");
+  const modulePath = path4.resolve(__dirname, "./project.js");
   const project = await viteSsrLoadModule(
     rootConfig,
     modulePath
   );
-  const schemas = project.getProjectSchemas();
-  const outputPath = path3.resolve(rootDir, "root-cms.d.ts");
+  const schemas = await project.getProjectSchemas();
+  const outputPath = path4.resolve(rootDir, "root-cms.d.ts");
   await generateSchemaDts(outputPath, schemas);
   console.log("saved root-cms.d.ts!");
 }
@@ -76,7 +76,7 @@ async function generateSchemaDts(outputPath, schemas) {
     dtsFormatter.addSchemaFile(fileId, schema);
   }
   const output = dtsFormatter.toString();
-  await fs2.writeFile(outputPath, output, "utf-8");
+  await fs3.writeFile(outputPath, output, "utf-8");
 }
 function fieldProperty(field, options) {
   const prop = dom.create.property(
@@ -129,12 +129,19 @@ function fieldType(field, options) {
     if (field.types && Array.isArray(field.types)) {
       const unionTypes = [];
       field.types.forEach((schema) => {
-        if (!schema.name) {
+        let typeName;
+        if (typeof schema === "string") {
+          typeName = schema;
+          return;
+        } else {
+          typeName = schema.name;
+        }
+        if (!typeName) {
           return;
         }
-        const cleanName = alphanumeric(schema.name);
+        const cleanName = alphanumeric(typeName);
         const oneOfTypeId = `${cleanName}Fields`;
-        if (!options.oneOfTypes[oneOfTypeId]) {
+        if (typeof schema === "object" && !options.oneOfTypes[oneOfTypeId]) {
           const oneOfTypeInterface = dom.create.interface(
             oneOfTypeId,
             dom.DeclarationFlags.Export
@@ -150,7 +157,7 @@ function fieldType(field, options) {
         }
         const oneOfOption = dom.create.namedTypeReference("RootCMSOneOfOption");
         oneOfOption.typeArguments = [
-          dom.type.stringLiteral(schema.name),
+          dom.type.stringLiteral(typeName),
           dom.create.namedTypeReference(oneOfTypeId)
         ];
         unionTypes.push(oneOfOption);
@@ -165,6 +172,10 @@ function fieldType(field, options) {
     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;
@@ -190,7 +201,7 @@ var __dirname, TEMPLATE, DtsFormatter;
 var init_generate_types = __esm({
   "cli/generate-types.ts"() {
     "use strict";
-    __dirname = path3.dirname(fileURLToPath(import.meta.url));
+    __dirname = path4.dirname(fileURLToPath(import.meta.url));
     TEMPLATE = `/* eslint-disable */
 /** Root.js CMS types. This file is autogenerated. */
 
@@ -264,7 +275,7 @@ export interface RootCMSDoc<Fields extends {}> {
       /** Adds the types for a `.schema.ts` file to the `.d.ts` file. */
       addSchemaFile(fileId, schema) {
         const jsdoc = `Generated from \`${fileId}\`.`;
-        const typeId = alphanumeric(path3.parse(fileId).name.split(".")[0]);
+        const typeId = alphanumeric(path4.parse(fileId).name.split(".")[0]);
         const oneOfTypes = {};
         const fieldsTypeId = `${typeId}Fields`;
         const fieldsType = dom.create.interface(
@@ -344,9 +355,10 @@ export interface RootCMSDoc<Fields extends {}> {
 });
 
 // core/plugin.ts
-import { promises as fs3 } from "node:fs";
-import path4 from "node:path";
+import { promises as fs4 } from "node:fs";
+import path5 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { viteSsrLoadModule as viteSsrLoadModule2 } from "@blinkk/root/node";
 import bodyParser from "body-parser";
 import {
   applicationDefault,
@@ -359,6 +371,8 @@ import * as jsonwebtoken from "jsonwebtoken";
 import sirv from "sirv";
 
 // core/api.ts
+import { promises as fs2 } from "node:fs";
+import path3 from "node:path";
 import { multipartMiddleware } from "@blinkk/root/middleware";
 
 // core/ai.ts
@@ -2192,21 +2206,48 @@ function csvToArray(csvString) {
 }
 
 // core/api.ts
+function testValidCollectionId(id) {
+  return /^[A-Za-z0-9_-]+$/.test(id);
+}
 function api(server, options) {
+  async function getCollectionSchema(req, collectionId) {
+    if (req.viteServer) {
+      const app = await options.getRenderer(req);
+      return await app.getCollection(collectionId);
+    }
+    try {
+      const schemaPath = path3.join(
+        req.rootConfig.rootDir,
+        "dist",
+        "collections",
+        `${collectionId}.schema.json`
+      );
+      const contents = await fs2.readFile(schemaPath, "utf8");
+      return JSON.parse(contents);
+    } catch (err) {
+      if (err && err.code === "ENOENT") {
+        return null;
+      }
+      throw err;
+    }
+  }
   server.use("/cms/api/collection.get", async (req, res) => {
     if (req.method !== "POST" || !String(req.get("content-type")).startsWith("application/json")) {
       res.status(400).json({ success: false, error: "BAD_REQUEST" });
       return;
     }
     const reqBody = req.body || {};
-    if (!reqBody.collectionId) {
+    const collectionId = String(reqBody.collectionId || "");
+    if (!collectionId) {
       res.status(400).json({ success: false, error: "MISSING_COLLECTION_ID" });
       return;
     }
+    if (!testValidCollectionId(collectionId)) {
+      res.status(400).json({ success: false, error: "INVALID_COLLECTION_ID" });
+      return;
+    }
     try {
-      const app = await options.getRenderer(req);
-      const collections = app.getCollections();
-      const collection = collections[reqBody.collectionId];
+      const collection = await getCollectionSchema(req, collectionId);
       if (!collection) {
         res.status(404).json({ success: false, error: "NOT_FOUND" });
         return;
@@ -2373,7 +2414,31 @@ function api(server, options) {
 }
 
 // core/plugin.ts
-var __dirname2 = path4.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+async function writeCollectionSchemasToJson(rootConfig) {
+  const modulePath = path5.resolve(__dirname2, "./project.js");
+  const project = await viteSsrLoadModule2(
+    rootConfig,
+    modulePath
+  );
+  const outDir = path5.join(rootConfig.rootDir, "dist", "collections");
+  await fs4.mkdir(outDir, { recursive: true });
+  const fileIds = Object.keys(project.SCHEMA_MODULES);
+  for (const fileId of fileIds) {
+    if (!fileId.startsWith("/collections/")) {
+      continue;
+    }
+    const collectionId = path5.basename(fileId).split(".")[0];
+    const schema = await project.getCollectionSchema(collectionId);
+    if (!schema) {
+      console.warn(`collection is missing a default export: ${fileId}`);
+      continue;
+    }
+    const jsonPath = path5.join(outDir, `${collectionId}.schema.json`);
+    const data = JSON.stringify(schema, null, 2);
+    await fs4.writeFile(jsonPath, data, "utf-8");
+  }
+}
 var SESSION_COOKIE_AUTH = "root-cms-auth";
 var NONCONF_STATIC_PATHS = [
   "/cms/static/signin.css",
@@ -2574,12 +2639,23 @@ function cmsPlugin(options) {
       const databaseId = firebaseConfig.databaseId || "(default)";
       return getFirestore(app, databaseId);
     },
+    hooks: {
+      /**
+       * Saves collection schema files from `collections/*.schema.ts` to
+       * `dist/collections/*.schema.json` for prod builds.
+       */
+      preBuild: async (rootConfig) => {
+        await writeCollectionSchemasToJson(rootConfig);
+      }
+    },
     /**
      * A map of ssr files to include when running `root build`.
      */
-    ssrInput: () => ({
-      cms: path4.resolve(__dirname2, "./app.js")
-    }),
+    ssrInput: () => {
+      return {
+        cms: path5.resolve(__dirname2, "./app.js")
+      };
+    },
     /**
      * Attaches CMS-specific middleware to the Root.js server.
      */
@@ -2587,13 +2663,13 @@ function cmsPlugin(options) {
       server.use(bodyParser.json());
       async function getRenderer(req) {
         if (serverOptions.type === "dev") {
-          const appFilePath = path4.resolve(__dirname2, "./app.js");
+          const appFilePath = path5.resolve(__dirname2, "./app.js");
           const app3 = await req.viteServer.ssrLoadModule(
             appFilePath
           );
           return app3;
         }
-        const appImportPath = path4.resolve(
+        const appImportPath = path5.resolve(
           req.rootConfig.rootDir,
           "dist/server/cms.js"
         );
@@ -2665,7 +2741,7 @@ function cmsPlugin(options) {
         }
         next();
       });
-      const staticDir = path4.resolve(__dirname2, "ui");
+      const staticDir = path5.resolve(__dirname2, "ui");
       server.use("/cms/static", sirv(staticDir, { dev: false }));
       api(server, { getRenderer });
       server.use("/cms", async (req, res) => {
@@ -2699,7 +2775,7 @@ function cmsPlugin(options) {
   return plugin;
 }
 function fileExists(filepath) {
-  return fs3.access(filepath).then(() => true).catch(() => false);
+  return fs4.access(filepath).then(() => true).catch(() => false);
 }
 export {
   cmsPlugin

package/dist/project.d.ts

@@ -1,5 +1,4 @@
-import { S as Schema } from './schema-KpQGOA1Z.js';
-import 'preact';
+import { S as Schema, C as Collection } from './schema-UCmjggdA.js';
 
 /**
  * Loads various files or configurations from the project.
@@ -11,6 +10,17 @@ import 'preact';
 interface SchemaModule {
     default: Schema;
 }
-declare function getProjectSchemas(): Record<string, Schema>;
+declare const SCHEMA_MODULES: Record<string, SchemaModule>;
+/**
+ * Returns a map of all `schema.ts` files defined in the project as
+ * fileId => schema. This is used by `generate-types.ts` to build the
+ * `root-cms.d.ts` file.
+ */
+declare function getProjectSchemas(): Promise<Record<string, Schema>>;
+/**
+ * Returns a collection's schema definition as defined in
+ * `/collections/<id>.schema.ts`.
+ */
+declare function getCollectionSchema(collectionId: string): Promise<Collection | null>;
 
-export { type SchemaModule, getProjectSchemas };
+export { SCHEMA_MODULES, type SchemaModule, getCollectionSchema, getProjectSchemas };

package/dist/project.js

@@ -1,14 +1,16 @@
 // core/project.ts
-var IGNORED_SCHEMA_FOLDERS = ["/appengine/", "/functions/", "/gae/"];
-var SCHEMA_MODULES = import.meta.glob("/**/*.schema.ts", {
-  eager: true
-});
-function getProjectSchemas() {
+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) {
-    if (IGNORED_SCHEMA_FOLDERS.some((prefix) => fileId.startsWith(prefix))) {
-      continue;
-    }
     const schemaModule = SCHEMA_MODULES[fileId];
     if (schemaModule.default) {
       schemas[fileId] = schemaModule.default;
@@ -16,6 +18,64 @@ function getProjectSchemas() {
   }
   return schemas;
 }
+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 convertOneOfTypes(collection) {
+  const clone = structuredClone(collection);
+  const types = clone.types || {};
+  function handleOneOfField(field) {
+    const names = [];
+    (field.types || []).forEach((sub) => {
+      if (typeof sub === "string") {
+        names.push(sub);
+        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,
+  getCollectionSchema,
   getProjectSchemas
 };