@blinkk/root-cms 1.0.0-alpha.9 → 1.0.0-beta.1

package/bin/root-cms.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {Command} from 'commander';
+import {bgGreen, black} from 'kleur/colors';
+import {initFirebase, generateTypes} from '../dist/cli.js';
+import {loadRootConfig} from '@blinkk/root/node';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const packageJson = require(path.join(__dirname, '../package.json'));
+
+async function main() {
+  console.log(`🌱 ${bgGreen(black(' root.js cms '))} v${packageJson.version}`);
+
+  const rootDir = process.cwd();
+  const rootConfig = await loadRootConfig(rootDir, {command: 'root-cms'});
+
+  const program = new Command('root-cms');
+  program.version(packageJson.version);
+  program
+    .command('init-firebase')
+    .description('inits the firebase project with proper security rules')
+    .option('--project <project>', 'gcp project id')
+    .action(initFirebase(rootConfig));
+  program
+    .command('generate-types')
+    .description('generates root-cms.d.ts from *.schema.ts files in the project')
+    .action(generateTypes(rootConfig));
+  await program.parseAsync(process.argv);
+}
+
+main();

package/dist/app.js

@@ -0,0 +1,190 @@
+// core/app.tsx
+import { render as renderToString } from "preact-render-to-string";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { jsx, jsxs } from "preact/jsx-runtime";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function App(props) {
+  return /* @__PURE__ */ jsxs("html", {
+    children: [
+      /* @__PURE__ */ jsxs("head", {
+        children: [
+          /* @__PURE__ */ jsx("title", {
+            children: props.title
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.googleapis.com"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.gstatic.com",
+            crossOrigin: "anonymous"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "https://fonts.googleapis.com/css2?family=Google+Sans:wght@500&display=swap"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "{CSS_URL}"
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsxs("body", {
+        children: [
+          /* @__PURE__ */ jsx("div", {
+            id: "root",
+            children: /* @__PURE__ */ jsxs("div", {
+              className: "bootstrap",
+              children: [
+                /* @__PURE__ */ jsx("h1", {
+                  className: "bootstrap__loading",
+                  children: "Loading..."
+                }),
+                /* @__PURE__ */ jsx("div", {
+                  className: "bootstrap-error",
+                  children: "If this page fails to load, try a force refresh by holding the shift key while refreshing the page."
+                })
+              ]
+            })
+          }),
+          /* @__PURE__ */ jsx("script", {
+            dangerouslySetInnerHTML: {
+              __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`
+            }
+          }),
+          /* @__PURE__ */ jsx("script", {
+            type: "module",
+            src: "{JS_URL}"
+          })
+        ]
+      })
+    ]
+  });
+}
+async function renderApp(req, res, options) {
+  const collectionModules = import.meta.glob("/collections/*.schema.ts", {
+    eager: true
+  });
+  const collections = {};
+  Object.keys(collectionModules).forEach((moduleId) => {
+    const collectionId = path.parse(moduleId).base.split(".")[0];
+    const module = collectionModules[moduleId];
+    const collection = module.default;
+    collections[collectionId] = collection;
+  });
+  const rootConfig = options.rootConfig || {};
+  const cmsConfig = options.cmsConfig || {};
+  const ctx = {
+    rootConfig: {
+      projectId: cmsConfig.id || "default",
+      domain: rootConfig.domain || "https://example.com"
+    },
+    firebaseConfig: options.firebaseConfig,
+    collections
+  };
+  const mainHtml = renderToString(/* @__PURE__ */ jsx(App, {
+    title: "Root.js CMS",
+    ctx
+  }));
+  let html = `<!doctype html>
+${mainHtml}`;
+  if (req.viteServer) {
+    const uiCssPath = path.join(__dirname, "ui/ui.css");
+    const uiJsPath = path.join(__dirname, "ui/ui.js");
+    const tpl = html.replace("{CSS_URL}", `/@fs${uiCssPath}`).replace("{JS_URL}", `/@fs${uiJsPath}`);
+    html = await req.viteServer.transformIndexHtml(req.originalUrl, tpl);
+  } else {
+    html = html.replace("{CSS_URL}", "/cms/static/ui.css").replace("{JS_URL}", "/cms/static/ui.js");
+  }
+  res.setHeader("Content-Type", "text/html");
+  res.send(html);
+}
+function SignIn(props) {
+  return /* @__PURE__ */ jsxs("html", {
+    children: [
+      /* @__PURE__ */ jsxs("head", {
+        children: [
+          /* @__PURE__ */ jsx("title", {
+            children: props.title
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.googleapis.com"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "preconnect",
+            href: "https://fonts.gstatic.com",
+            crossOrigin: "anonymous"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap"
+          }),
+          /* @__PURE__ */ jsx("link", {
+            rel: "stylesheet",
+            href: "{CSS_URL}"
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsxs("body", {
+        children: [
+          /* @__PURE__ */ jsx("div", {
+            id: "root",
+            children: /* @__PURE__ */ jsxs("div", {
+              className: "bootstrap",
+              children: [
+                /* @__PURE__ */ jsx("h1", {
+                  className: "bootstrap__loading",
+                  children: "Loading..."
+                }),
+                /* @__PURE__ */ jsx("div", {
+                  className: "bootstrap-error",
+                  children: "If this page fails to load, try a force refresh by holding the shift key while refreshing the page."
+                })
+              ]
+            })
+          }),
+          /* @__PURE__ */ jsx("script", {
+            dangerouslySetInnerHTML: {
+              __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`
+            }
+          }),
+          /* @__PURE__ */ jsx("script", {
+            type: "module",
+            src: "{JS_URL}"
+          })
+        ]
+      })
+    ]
+  });
+}
+async function renderSignIn(req, res, options) {
+  const ctx = { firebaseConfig: options.firebaseConfig };
+  const mainHtml = renderToString(/* @__PURE__ */ jsx(SignIn, {
+    title: "Sign in",
+    ctx
+  }));
+  let html = `<!doctype html>
+${mainHtml}`;
+  if (req.viteServer) {
+    const cssPath = path.join(__dirname, "ui/signin.css");
+    const jsPath = path.join(__dirname, "ui/signin.js");
+    const tpl = html.replace("{CSS_URL}", `/@fs${cssPath}`).replace("{JS_URL}", `/@fs${jsPath}`);
+    html = await req.viteServer.transformIndexHtml(req.originalUrl, tpl);
+  } else {
+    html = html.replace("{CSS_URL}", "/cms/static/signin.css").replace("{JS_URL}", "/cms/static/signin.js");
+  }
+  res.setHeader("Content-Type", "text/html");
+  res.send(html);
+}
+export {
+  renderApp,
+  renderSignIn
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../core/app.tsx"],
  "sourcesContent": ["import {Request, Response} from '@blinkk/root';\nimport {Collection} from './schema.js';\nimport {render as renderToString} from 'preact-render-to-string';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\ninterface AppProps {\n  title: string;\n  ctx: any;\n}\n\nfunction App(props: AppProps) {\n  return (\n    <html>\n      <head>\n        <title>{props.title}</title>\n        <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n        <link\n          rel=\"preconnect\"\n          href=\"https://fonts.gstatic.com\"\n          crossOrigin=\"anonymous\"\n        />\n        <link\n          rel=\"stylesheet\"\n          href=\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap\"\n        />\n        <link\n          rel=\"stylesheet\"\n          href=\"https://fonts.googleapis.com/css2?family=Google+Sans:wght@500&display=swap\"\n        />\n        <link rel=\"stylesheet\" href=\"{CSS_URL}\" />\n      </head>\n      <body>\n        <div id=\"root\">\n          <div className=\"bootstrap\">\n            <h1 className=\"bootstrap__loading\">Loading...</h1>\n            <div className=\"bootstrap-error\">\n              If this page fails to load, try a force refresh by holding the\n              shift key while refreshing the page.\n            </div>\n          </div>\n        </div>\n        <script\n          dangerouslySetInnerHTML={{\n            __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`,\n          }}\n        />\n        <script type=\"module\" src=\"{JS_URL}\"></script>\n      </body>\n    </html>\n  );\n}\n\nexport async function renderApp(req: Request, res: Response, options: any) {\n  const collectionModules = import.meta.glob('/collections/*.schema.ts', {\n    eager: true,\n  }) as any;\n  const collections: Record<string, Collection> = {};\n  Object.keys(collectionModules).forEach((moduleId: string) => {\n    const collectionId = path.parse(moduleId).base.split('.')[0];\n    const module = collectionModules[moduleId];\n    const collection = module.default as Collection;\n    collections[collectionId] = collection;\n  });\n  const rootConfig = options.rootConfig || {};\n  const cmsConfig = options.cmsConfig || {};\n  const ctx = {\n    rootConfig: {\n      projectId: cmsConfig.id || 'default',\n      domain: rootConfig.domain || 'https://example.com',\n    },\n    firebaseConfig: options.firebaseConfig,\n    collections: collections,\n  };\n  const mainHtml = renderToString(<App title=\"Root.js CMS\" ctx={ctx} />);\n  let html = `<!doctype html>\\n${mainHtml}`;\n  if (req.viteServer) {\n    const uiCssPath = path.join(__dirname, 'ui/ui.css');\n    const uiJsPath = path.join(__dirname, 'ui/ui.js');\n    const tpl = html\n      .replace('{CSS_URL}', `/@fs${uiCssPath}`)\n      .replace('{JS_URL}', `/@fs${uiJsPath}`);\n    html = await req.viteServer!.transformIndexHtml(req.originalUrl, tpl);\n  } else {\n    html = html\n      .replace('{CSS_URL}', '/cms/static/ui.css')\n      .replace('{JS_URL}', '/cms/static/ui.js');\n  }\n  res.setHeader('Content-Type', 'text/html');\n  res.send(html);\n}\n\ninterface SignInProps {\n  title: string;\n  ctx: any;\n}\n\nfunction SignIn(props: SignInProps) {\n  return (\n    <html>\n      <head>\n        <title>{props.title}</title>\n        <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n        <link\n          rel=\"preconnect\"\n          href=\"https://fonts.gstatic.com\"\n          crossOrigin=\"anonymous\"\n        />\n        <link\n          rel=\"stylesheet\"\n          href=\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;900&display=swap\"\n        />\n        <link rel=\"stylesheet\" href=\"{CSS_URL}\" />\n      </head>\n      <body>\n        <div id=\"root\">\n          <div className=\"bootstrap\">\n            <h1 className=\"bootstrap__loading\">Loading...</h1>\n            <div className=\"bootstrap-error\">\n              If this page fails to load, try a force refresh by holding the\n              shift key while refreshing the page.\n            </div>\n          </div>\n        </div>\n        <script\n          dangerouslySetInnerHTML={{\n            __html: `window.__ROOT_CTX = ${JSON.stringify(props.ctx)}`,\n          }}\n        />\n        <script type=\"module\" src=\"{JS_URL}\"></script>\n      </body>\n    </html>\n  );\n}\nexport async function renderSignIn(req: Request, res: Response, options: any) {\n  const ctx = {firebaseConfig: options.firebaseConfig};\n  const mainHtml = renderToString(<SignIn title=\"Sign in\" ctx={ctx} />);\n  let html = `<!doctype html>\\n${mainHtml}`;\n  if (req.viteServer) {\n    const cssPath = path.join(__dirname, 'ui/signin.css');\n    const jsPath = path.join(__dirname, 'ui/signin.js');\n    const tpl = html\n      .replace('{CSS_URL}', `/@fs${cssPath}`)\n      .replace('{JS_URL}', `/@fs${jsPath}`);\n    html = await req.viteServer!.transformIndexHtml(req.originalUrl, tpl);\n  } else {\n    html = html\n      .replace('{CSS_URL}', '/cms/static/signin.css')\n      .replace('{JS_URL}', '/cms/static/signin.js');\n  }\n  res.setHeader('Content-Type', 'text/html');\n  res.send(html);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/cli.js

@@ -0,0 +1,228 @@
+// core/runtime.ts
+import { initializeApp, getApps, applicationDefault } from "firebase-admin/app";
+import { getFirestore } from "firebase-admin/firestore";
+function getFirebaseApp(gcpProjectId) {
+  const apps = getApps();
+  if (apps.length > 0 && apps[0]) {
+    return apps[0];
+  }
+  return initializeApp({
+    projectId: gcpProjectId,
+    credential: applicationDefault()
+  });
+}
+function getCmsPlugin(rootConfig) {
+  const plugins = rootConfig.plugins || [];
+  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
+  if (!plugin) {
+    throw new Error("could not find root-cms plugin config in root.config.ts");
+  }
+  return plugin;
+}
+
+// core/security.ts
+import { getSecurityRules } from "firebase-admin/security-rules";
+var FIRESTORE_RULES = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    match /Projects/{project}/{document=**} {
+      allow write:
+        if request.auth != null
+        && exists(/databases/$(database)/documents/Projects/$(project))
+        && get(/databases/$(database)/documents/Projects/$(project)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR'];
+      allow read:
+        if request.auth != null
+        && exists(/databases/$(database)/documents/Projects/$(project))
+        && get(/databases/$(database)/documents/Projects/$(project)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR', 'VIEWER'];
+    }
+
+    match /Projects/{project}/Collections/{collection}/{document=**} {
+      allow write:
+        if request.auth != null
+        && exists(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection))
+        && get(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR'];
+      allow read:
+        if request.auth != null
+        && exists(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection))
+        && get(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR', 'VIEWER'];
+    }
+  }
+}
+`;
+async function applySecurityRules(projectId) {
+  const app = getFirebaseApp(projectId);
+  const securityRules = getSecurityRules(app);
+  await securityRules.releaseFirestoreRulesetFromSource(FIRESTORE_RULES);
+}
+
+// cli/commands/init-firebase.ts
+function initFirebase(rootConfig) {
+  return (options) => {
+    let gcpProjectId;
+    if (options.project) {
+      gcpProjectId = options.project;
+    } else {
+      const cmsPlugin = getCmsPlugin(rootConfig);
+      const cmsPluginOptions = cmsPlugin.getConfig();
+      gcpProjectId = cmsPluginOptions.firebaseConfig.projectId;
+    }
+    if (!gcpProjectId) {
+      throw new Error("firebaseConfig.projectId not set in cms plugin options");
+    }
+    console.log(`gcp project: ${gcpProjectId}`);
+    console.log("\u{1F46E} updating security rules...");
+    applySecurityRules(gcpProjectId);
+    console.log("done initializing firebase project!");
+  };
+}
+
+// cli/commands/generate-types.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { viteSsrLoadModule } from "@blinkk/root/node";
+import * as dom from "dts-dom";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function generateTypes(rootConfig) {
+  const rootDir = rootConfig.rootDir;
+  return async () => {
+    const modulePath = path.resolve(__dirname, "./project.js");
+    const project = await viteSsrLoadModule(
+      rootConfig,
+      modulePath
+    );
+    const schemas = project.getProjectSchemas();
+    console.log(`generating root-cms.d.ts from ${rootDir}...`);
+    const outputPath = path.resolve(rootDir, "root-cms.d.ts");
+    await generateSchemaDts(outputPath, schemas);
+    console.log("saved root-cms.d.ts!");
+  };
+}
+var TEMPLATE = `/** Root.js CMS types. This file is autogenerated. */
+
+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". */
+    collectionId: 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?: string;
+        firstPublishedBy?: string;
+        publishedAt?: string;
+        publishedBy?: string;
+    };
+    /** User-entered field values from the CMS. */
+    fields?: Fields;
+}`;
+async function generateSchemaDts(outputPath, schemas) {
+  const results = [TEMPLATE];
+  for (const fileId in schemas) {
+    const schema = schemas[fileId];
+    results.push(renderSchema(fileId, schema));
+  }
+  const output = results.join("\n\n").replaceAll("/**  ", "/** ").replaceAll("  */", " */").replace(/\r\n|\r|\n/g, "\n");
+  await fs.writeFile(outputPath, output, "utf-8");
+}
+function fieldProperty(field) {
+  const prop = dom.create.property(
+    field.id,
+    fieldType(field),
+    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) {
+  if (field.type === "array") {
+    return dom.type.array(fieldType(field.of));
+  }
+  if (field.type === "image") {
+    return dom.create.objectType([
+      dom.create.property("src", dom.type.string),
+      dom.create.property(
+        "alt",
+        dom.type.string,
+        dom.DeclarationFlags.Optional
+      ),
+      dom.create.property(
+        "width",
+        dom.type.number,
+        dom.DeclarationFlags.Optional
+      ),
+      dom.create.property(
+        "height",
+        dom.type.number,
+        dom.DeclarationFlags.Optional
+      )
+    ]);
+  }
+  if (field.type === "multiselect") {
+    return dom.type.array(dom.type.string);
+  }
+  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));
+    return dom.create.objectType(subproperties);
+  }
+  return dom.type.unknown;
+}
+function renderSchema(fileId, schema) {
+  const jsdoc = `Generated from \`${fileId}\`.`;
+  const id = path.parse(fileId).name.split(".")[0];
+  const fieldsInterface = `${id}Fields`;
+  const fields = dom.create.interface(
+    fieldsInterface,
+    dom.DeclarationFlags.Export
+  );
+  fields.jsDocComment = jsdoc;
+  for (const field of schema.fields) {
+    if (!field.id) {
+      continue;
+    }
+    fields.members.push(fieldProperty(field));
+  }
+  const fieldsTypeOutput = dom.emit(fields, { singleLineJsDocComments: true }).trim();
+  if (fileId.startsWith("/collections/")) {
+    const baseType = dom.create.namedTypeReference("RootCMSDoc");
+    baseType.typeArguments.push(dom.create.namedTypeReference(fieldsInterface));
+    const docType = dom.create.alias(
+      `${id}Doc`,
+      baseType,
+      dom.DeclarationFlags.Export
+    );
+    docType.jsDocComment = jsdoc;
+    const docTypeOutput = dom.emit(docType, { singleLineJsDocComments: true }).trim();
+    return fieldsTypeOutput + "\n\n" + docTypeOutput;
+  }
+  return fieldsTypeOutput;
+}
+export {
+  generateTypes,
+  initFirebase
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../core/runtime.ts", "../core/security.ts", "../cli/commands/init-firebase.ts", "../cli/commands/generate-types.ts"],
  "sourcesContent": ["import {Plugin, RootConfig} from '@blinkk/root';\nimport {initializeApp, getApps, applicationDefault} from 'firebase-admin/app';\nimport {getFirestore} from 'firebase-admin/firestore';\nimport {CMSPlugin} from './plugin.js';\n\nexport function getFirebaseApp(gcpProjectId: string) {\n  const apps = getApps();\n  if (apps.length > 0 && apps[0]) {\n    return apps[0];\n  }\n  return initializeApp({\n    projectId: gcpProjectId,\n    credential: applicationDefault(),\n  });\n}\n\n/**\n * Retrieves a doc from Root.js CMS.\n */\nexport async function getDoc<T>(\n  rootConfig: RootConfig,\n  collectionId: string,\n  slug: string,\n  options: {mode: 'draft' | 'published'}\n): Promise<T | null> {\n  const cmsPlugin = getCmsPlugin(rootConfig);\n  const cmsPluginOptions = cmsPlugin.getConfig();\n  const projectId = cmsPluginOptions.id || 'default';\n  const gcpProjectId = cmsPluginOptions.firebaseConfig.projectId;\n  const mode = options.mode;\n  const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n  const app = getFirebaseApp(gcpProjectId);\n  const db = getFirestore(app);\n  // Slugs with slashes are encoded as `--` in the DB.\n  slug = slug.replaceAll('/', '--');\n  const dbPath = `Projects/${projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;\n  const docRef = db.doc(dbPath);\n  const doc = await docRef.get();\n  if (doc.exists) {\n    const data = doc.data();\n    return normalizeData(data) as T;\n  }\n  console.log(`doc not found: ${dbPath}`);\n  return null;\n}\n\n/**\n * Walks the data tree and converts any Timestamp objects to millis and any\n * _array maps to normal arrays.\n *\n * E.g.:\n *\n * normalizeData({\n *   sys: {modifiedAt: Timestamp(123)},\n *   fields: {\n *     _array: ['asdf'],\n *     asdf: {title: 'hello'}\n *   }\n * })\n * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}\n */\nexport function normalizeData(data: any): any {\n  const result: any = {};\n  for (const key in data) {\n    const val = data[key];\n    if (isObject(val)) {\n      if (val.toMillis) {\n        result[key] = val.toMillis();\n      } else if (Object.hasOwn(val, '_array') && Array.isArray(val._array)) {\n        const arr = val._array.map((k: string) => val[k] || {});\n        result[key] = arr;\n      } else {\n        result[key] = normalizeData(val);\n      }\n    } else {\n      result[key] = val;\n    }\n  }\n  return result;\n}\n\nfunction isObject(data: any): boolean {\n  return typeof data === 'object' && !Array.isArray(data) && data !== null;\n}\n\nexport function getCmsPlugin(rootConfig: RootConfig): CMSPlugin {\n  const plugins: Plugin[] = rootConfig.plugins || [];\n  const plugin = plugins.find((plugin) => plugin.name === 'root-cms');\n  if (!plugin) {\n    throw new Error('could not find root-cms plugin config in root.config.ts');\n  }\n  return plugin as CMSPlugin;\n}\n", "import {getSecurityRules} from 'firebase-admin/security-rules';\nimport {getFirebaseApp} from './runtime.js';\n\nexport const FIRESTORE_RULES = `rules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /Projects/{project}/{document=**} {\n      allow write:\n        if request.auth != null\n        && exists(/databases/$(database)/documents/Projects/$(project))\n        && get(/databases/$(database)/documents/Projects/$(project)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR'];\n      allow read:\n        if request.auth != null\n        && exists(/databases/$(database)/documents/Projects/$(project))\n        && get(/databases/$(database)/documents/Projects/$(project)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR', 'VIEWER'];\n    }\n\n    match /Projects/{project}/Collections/{collection}/{document=**} {\n      allow write:\n        if request.auth != null\n        && exists(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection))\n        && get(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR'];\n      allow read:\n        if request.auth != null\n        && exists(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection))\n        && get(/databases/$(database)/documents/Projects/$(project)/Collections/$(collection)).data.roles[request.auth.token.email] in ['ADMIN', 'EDITOR', 'VIEWER'];\n    }\n  }\n}\n`;\n\n/**\n * Adds the root-cms security rules to a Firebase project.\n * NOTE: This function will overwrite any existing rules.\n */\nexport async function applySecurityRules(projectId: string) {\n  const app = getFirebaseApp(projectId);\n  const securityRules = getSecurityRules(app);\n  await securityRules.releaseFirestoreRulesetFromSource(FIRESTORE_RULES);\n}\n", "import {RootConfig} from '@blinkk/root';\nimport {getCmsPlugin} from '../../core/runtime.js';\nimport {applySecurityRules} from '../../core/security.js';\n\nexport interface InitFirebaseOptions {\n  /** GCP project id. */\n  project?: string;\n}\n\nexport function initFirebase(rootConfig: RootConfig) {\n  return (options: InitFirebaseOptions) => {\n    let gcpProjectId: string;\n    if (options.project) {\n      gcpProjectId = options.project;\n    } else {\n      const cmsPlugin = getCmsPlugin(rootConfig);\n      const cmsPluginOptions = cmsPlugin.getConfig();\n      gcpProjectId = cmsPluginOptions.firebaseConfig.projectId;\n    }\n    if (!gcpProjectId) {\n      throw new Error('firebaseConfig.projectId not set in cms plugin options');\n    }\n\n    console.log(`gcp project: ${gcpProjectId}`);\n    console.log('\uD83D\uDC6E updating security rules...');\n    applySecurityRules(gcpProjectId);\n    console.log('done initializing firebase project!');\n  };\n}\n", "import {promises as fs} from 'node:fs';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport {viteSsrLoadModule} from '@blinkk/root/node';\nimport {RootConfig} from '@blinkk/root';\nimport * as dom from 'dts-dom';\nimport {Field, Schema} from '../../core/schema.js';\n\ntype ProjectModule = typeof import('../../core/project.js');\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nexport function generateTypes(rootConfig: RootConfig) {\n  const rootDir = rootConfig.rootDir;\n  return async () => {\n    const modulePath = path.resolve(__dirname, './project.js');\n    const project = (await viteSsrLoadModule(\n      rootConfig,\n      modulePath\n    )) as ProjectModule;\n    const schemas = project.getProjectSchemas();\n    console.log(`generating root-cms.d.ts from ${rootDir}...`);\n    const outputPath = path.resolve(rootDir, 'root-cms.d.ts');\n    await generateSchemaDts(outputPath, schemas);\n    console.log('saved root-cms.d.ts!');\n  };\n}\n\n// The `dts-dom` package uses 4-space indents, use the same for consistency.\nconst TEMPLATE = `/** Root.js CMS types. This file is autogenerated. */\n\nexport interface RootCMSDoc<Fields extends {}> {\n    /** The id of the doc, e.g. \"Pages/foo-bar\". */\n    id: string;\n    /** The collection id of the doc, e.g. \"Pages\". */\n    collectionId: string;\n    /** The slug of the doc, e.g. \"foo-bar\". */\n    slug: string;\n    /** System-level metadata. */\n    sys: {\n        createdAt: number;\n        createdBy: string;\n        modifiedAt: number;\n        modifiedBy: string;\n        firstPublishedAt?: string;\n        firstPublishedBy?: string;\n        publishedAt?: string;\n        publishedBy?: string;\n    };\n    /** User-entered field values from the CMS. */\n    fields?: Fields;\n}`;\n\n/**\n * Generates a root-cms.d.ts file from the .schema.ts files in the project.\n */\nexport async function generateSchemaDts(\n  outputPath: string,\n  schemas: Record<string, Schema>\n) {\n  const results = [TEMPLATE];\n  for (const fileId in schemas) {\n    const schema = schemas[fileId];\n    results.push(renderSchema(fileId, schema));\n  }\n  const output = results\n    .join('\\n\\n')\n    .replaceAll('/**  ', '/** ')\n    .replaceAll('  */', ' */')\n    .replace(/\\r\\n|\\r|\\n/g, '\\n');\n  await fs.writeFile(outputPath, output, 'utf-8');\n}\n\nfunction fieldProperty(field: Field): dom.PropertyDeclaration {\n  const prop = dom.create.property(\n    field.id!,\n    fieldType(field),\n    dom.DeclarationFlags.Optional\n  );\n  const jsdoc = [];\n  if (field.label) {\n    if (field.help) {\n      jsdoc.push(`${field.label}. ${field.help}`);\n    } else {\n      jsdoc.push(field.label);\n    }\n  }\n  if (field.deprecated) {\n    jsdoc.push('@deprecated');\n  }\n  if (jsdoc.length > 0) {\n    prop.jsDocComment = jsdoc.join('\\n');\n  }\n  return prop;\n}\n\nfunction fieldType(field: Field): dom.Type {\n  if (field.type === 'array') {\n    return dom.type.array(fieldType(field.of));\n  }\n  if (field.type === 'image') {\n    return dom.create.objectType([\n      dom.create.property('src', dom.type.string),\n      dom.create.property(\n        'alt',\n        dom.type.string,\n        dom.DeclarationFlags.Optional\n      ),\n      dom.create.property(\n        'width',\n        dom.type.number,\n        dom.DeclarationFlags.Optional\n      ),\n      dom.create.property(\n        'height',\n        dom.type.number,\n        dom.DeclarationFlags.Optional\n      ),\n    ]);\n  }\n  if (field.type === 'multiselect') {\n    return dom.type.array(dom.type.string);\n  }\n  if (field.type === 'select') {\n    return dom.type.string;\n  }\n  if (field.type === 'string') {\n    return dom.type.string;\n  }\n  if (field.type === 'object') {\n    const subproperties = (field.fields || []).map((f) => fieldProperty(f));\n    return dom.create.objectType(subproperties);\n  }\n  return dom.type.unknown;\n}\n\nfunction renderSchema(fileId: string, schema: Schema): string {\n  const jsdoc = `Generated from \\`${fileId}\\`.`;\n  const id = path.parse(fileId).name.split('.')[0];\n  const fieldsInterface = `${id}Fields`;\n  const fields = dom.create.interface(\n    fieldsInterface,\n    dom.DeclarationFlags.Export\n  );\n  fields.jsDocComment = jsdoc;\n  for (const field of schema.fields) {\n    if (!field.id) {\n      continue;\n    }\n    fields.members.push(fieldProperty(field));\n  }\n\n  const fieldsTypeOutput = dom\n    .emit(fields, {singleLineJsDocComments: true})\n    .trim();\n  if (fileId.startsWith('/collections/')) {\n    const baseType = dom.create.namedTypeReference('RootCMSDoc');\n    baseType.typeArguments.push(dom.create.namedTypeReference(fieldsInterface));\n    const docType = dom.create.alias(\n      `${id}Doc`,\n      baseType,\n      dom.DeclarationFlags.Export\n    );\n    docType.jsDocComment = jsdoc;\n\n    const docTypeOutput = dom\n      .emit(docType, {singleLineJsDocComments: true})\n      .trim();\n    return fieldsTypeOutput + '\\n\\n' + docTypeOutput;\n  }\n  return fieldsTypeOutput;\n}\n"],
  "mappings": "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",
  "names": ["plugin"]
}


package/dist/core.d.ts

@@ -0,0 +1,33 @@
+export { s as schema } from './schema-f8000274.js';
+import * as firebase_admin_app from 'firebase-admin/app';
+import { RootConfig } from '@blinkk/root';
+import { CMSPlugin } from './plugin.js';
+import 'preact';
+import 'firebase-admin/auth';
+
+declare function getFirebaseApp(gcpProjectId: string): firebase_admin_app.App;
+/**
+ * Retrieves a doc from Root.js CMS.
+ */
+declare function getDoc<T>(rootConfig: RootConfig, collectionId: string, slug: string, options: {
+    mode: 'draft' | 'published';
+}): Promise<T | null>;
+/**
+ * Walks the data tree and converts any Timestamp objects to millis and any
+ * _array maps to normal arrays.
+ *
+ * E.g.:
+ *
+ * normalizeData({
+ *   sys: {modifiedAt: Timestamp(123)},
+ *   fields: {
+ *     _array: ['asdf'],
+ *     asdf: {title: 'hello'}
+ *   }
+ * })
+ * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}
+ */
+declare function normalizeData(data: any): any;
+declare function getCmsPlugin(rootConfig: RootConfig): CMSPlugin;
+
+export { getCmsPlugin, getDoc, getFirebaseApp, normalizeData };