@blinkk/root-cms 1.0.1-alpha.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-2024 Blinkk LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# Setting up Firestore
+
+Firestore must be setup as `Native Mode` and not `Datastore Mode`
+
+Firestore read/writes will need to be locked down by adding the following to the security rules (in Firebase's Firestore UI):
+```
+rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    match /{document=**} {
+      allow read, write: if false;
+    }
+
+    match /Projects/{project} {
+      allow write:
+        if isSignedIn() && userIsAdmin();
+      allow read:
+        if isSignedIn() && userCanRead();
+
+      match /{collection}/{document=**} {
+        allow write:
+          if isSignedIn() && userCanWrite();
+        allow read:
+          if isSignedIn() && userCanRead();
+      }
+
+      function isSignedIn() {
+        return request.auth != null;
+      }
+
+      function getRoles() {
+        return get(/databases/$(database)/documents/Projects/$(project)).data.roles;
+      }
+
+      function userCanRead() {
+        let roles = getRoles();
+        let email = request.auth.token.email;
+        let domain = '*@' + email.split('@')[1];
+        return (roles[email] in ['ADMIN', 'EDITOR', 'VIEWER']) || (roles[domain] in ['ADMIN', 'EDITOR', 'VIEWER']);
+      }
+
+      function userCanWrite() {
+        let roles = getRoles();
+        let email = request.auth.token.email;
+        let domain = '*@' + email.split('@')[1];
+        return (roles[email] in ['ADMIN', 'EDITOR']) || (roles[domain] in ['ADMIN', 'EDITOR']);
+      }
+
+      function userIsAdmin() {
+        let roles = getRoles();
+        let email = request.auth.token.email;
+        let domain = '*@' + email.split('@')[1];
+        return (roles[email] == 'ADMIN') || (roles[domain] == 'ADMIN');
+      }
+    }
+  }
+}
+```
+
+In Firestore, add a document at `Projects/<yourprojectid>` with a value of `{roles: {"youremail@yourdomain.tld": "ADMIN"}}`.
+
+Using Firestore Studio:
+- Under `Give the collection an ID`, set `Collection ID` to `Projects`
+- Under `Add its first document` set `Document ID` to your project ID
+- For the first record set `Field name` to `roles` with a `Field type` of `map`
+- In the map set the new `Field name` to your e-mail, `Field type` to `string` and `Field value` to `ADMIN` and save.

package/bin/root-cms.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+import {createRequire} from 'node:module';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {CliRunner} from '../dist/cli.js';
+
+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(argv) {
+  const cli = new CliRunner('root-cms', packageJson.version);
+  await cli.run(argv);
+}
+
+main(process.argv);

package/dist/app.js

@@ -0,0 +1,212 @@
+// core/app.tsx
+import crypto from "node:crypto";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { render as renderToString } from "preact-render-to-string";
+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",
+          nonce: "{NONCE}"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "link",
+        {
+          rel: "stylesheet",
+          href: "https://fonts.googleapis.com/css2?family=Google+Sans:wght@500&display=swap",
+          nonce: "{NONCE}"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "link",
+        {
+          rel: "icon",
+          href: "https://lh3.googleusercontent.com/ijK50TfQlV_yJw3i-CMlnD6osH4PboZBILZrJcWhoNMEmoyCD5e1bAxXbaOPe5w4gG_Scf37EXrmZ6p8sP2lue5fLZ419m5JyLMs=e385-w256",
+          type: "image/png"
+        }
+      ),
+      /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: "{CSS_URL}", nonce: "{NONCE}" })
+    ] }),
+    /* @__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)}`
+          },
+          nonce: "{NONCE}"
+        }
+      ),
+      /* @__PURE__ */ jsx("script", { type: "module", src: "{JS_URL}", nonce: "{NONCE}" })
+    ] })
+  ] });
+}
+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 || {};
+  let gci = cmsConfig.gci;
+  if (gci === true) {
+    gci = "https://gci.rootjs.dev";
+  }
+  const ctx = {
+    rootConfig: {
+      projectId: cmsConfig.id || "default",
+      projectName: cmsConfig.name || cmsConfig.id || "",
+      domain: rootConfig.domain || "https://example.com",
+      base: rootConfig.base || "/",
+      gci,
+      i18n: rootConfig.i18n
+    },
+    firebaseConfig: options.firebaseConfig,
+    gapi: cmsConfig.gapi,
+    collections
+  };
+  const projectName = cmsConfig.name || cmsConfig.id || "";
+  const title = projectName ? `${projectName} \u2013 Root.js CMS` : "Root.js CMS";
+  const mainHtml = renderToString(/* @__PURE__ */ jsx(App, { title, ctx }));
+  let html = `<!doctype html>
+${mainHtml}`;
+  const nonce = generateNonce();
+  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}`).replaceAll("{NONCE}", nonce);
+    html = await req.viteServer.transformIndexHtml(req.originalUrl, tpl);
+    html = html.replace(
+      '<script type="module" src="/@vite/client"></script>',
+      `<script type="module" src="/@vite/client" nonce="${nonce}"></script>`
+    );
+  } else {
+    html = html.replace("{CSS_URL}", "/cms/static/ui.css").replace("{JS_URL}", "/cms/static/ui.js").replaceAll("{NONCE}", nonce);
+  }
+  res.setHeader("Content-Type", "text/html");
+  setSecurityHeaders(res, nonce);
+  res.send(html);
+}
+function SignIn(props) {
+  return /* @__PURE__ */ jsxs("html", { children: [
+    /* @__PURE__ */ jsxs("head", { children: [
+      /* @__PURE__ */ jsx("meta", { charset: "utf-8" }),
+      /* @__PURE__ */ jsx("title", { children: props.title }),
+      /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.googleapis.com" }),
+      /* @__PURE__ */ jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" }),
+      /* @__PURE__ */ jsx(
+        "link",
+        {
+          rel: "preconnect",
+          href: "https://fonts.gstatic.com",
+          crossOrigin: "anonymous"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "link",
+        {
+          rel: "stylesheet",
+          href: "https://fonts.googleapis.com/css?family=Google+Sans:400,500&display=swap",
+          nonce: "{NONCE}"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "link",
+        {
+          rel: "icon",
+          href: "https://lh3.googleusercontent.com/ijK50TfQlV_yJw3i-CMlnD6osH4PboZBILZrJcWhoNMEmoyCD5e1bAxXbaOPe5w4gG_Scf37EXrmZ6p8sP2lue5fLZ419m5JyLMs=e385-w256",
+          type: "image/png"
+        }
+      ),
+      /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: "{CSS_URL}", nonce: "{NONCE}" })
+    ] }),
+    /* @__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)}`
+          },
+          nonce: "{NONCE}"
+        }
+      ),
+      /* @__PURE__ */ jsx("script", { type: "module", src: "{JS_URL}", nonce: "{NONCE}" })
+    ] })
+  ] });
+}
+async function renderSignIn(req, res, options) {
+  const ctx = { name: options.name, firebaseConfig: options.firebaseConfig };
+  const mainHtml = renderToString(/* @__PURE__ */ jsx(SignIn, { title: "Sign in", ctx }));
+  let html = `<!doctype html>
+${mainHtml}`;
+  const nonce = generateNonce();
+  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}`).replaceAll("{NONCE}", nonce);
+    html = await req.viteServer.transformIndexHtml(req.originalUrl, tpl);
+    html = html.replace(
+      '<script type="module" src="/@vite/client"></script>',
+      `<script type="module" src="/@vite/client" nonce="${nonce}"></script>`
+    );
+  } else {
+    html = html.replace("{CSS_URL}", "/cms/static/signin.css").replace("{JS_URL}", "/cms/static/signin.js").replaceAll("{NONCE}", nonce);
+  }
+  res.setHeader("Content-Type", "text/html");
+  setSecurityHeaders(res, nonce);
+  res.send(html);
+}
+function generateNonce() {
+  return crypto.randomBytes(16).toString("base64");
+}
+function setSecurityHeaders(res, nonce) {
+  res.setHeader("x-frame-options", "SAMEORIGIN");
+  res.setHeader(
+    "strict-transport-security",
+    "max-age=63072000; includeSubdomains; preload"
+  );
+  res.setHeader("x-content-type-options", "nosniff");
+  res.setHeader("x-xss-protection", "1; mode=block");
+  const directives = [
+    "base-uri 'none'",
+    "object-src 'none'",
+    `script-src 'nonce-${nonce}' 'unsafe-inline' 'unsafe-eval' 'strict-dynamic' https: http:`
+  ];
+  res.setHeader("content-security-policy-report-only", directives.join(";"));
+}
+export {
+  renderApp,
+  renderSignIn
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../core/app.tsx"],
  "sourcesContent": ["import crypto from 'node:crypto';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport {Request, Response} from '@blinkk/root';\nimport {render as renderToString} from 'preact-render-to-string';\nimport {Collection} from './schema.js';\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          nonce=\"{NONCE}\"\n        />\n        <link\n          rel=\"stylesheet\"\n          href=\"https://fonts.googleapis.com/css2?family=Google+Sans:wght@500&display=swap\"\n          nonce=\"{NONCE}\"\n        />\n        <link\n          rel=\"icon\"\n          href=\"https://lh3.googleusercontent.com/ijK50TfQlV_yJw3i-CMlnD6osH4PboZBILZrJcWhoNMEmoyCD5e1bAxXbaOPe5w4gG_Scf37EXrmZ6p8sP2lue5fLZ419m5JyLMs=e385-w256\"\n          type=\"image/png\"\n        />\n        <link rel=\"stylesheet\" href=\"{CSS_URL}\" nonce=\"{NONCE}\" />\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          nonce=\"{NONCE}\"\n        />\n        <script type=\"module\" src=\"{JS_URL}\" nonce=\"{NONCE}\"></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  let gci = cmsConfig.gci;\n  if (gci === true) {\n    gci = 'https://gci.rootjs.dev';\n  }\n  const ctx = {\n    rootConfig: {\n      projectId: cmsConfig.id || 'default',\n      projectName: cmsConfig.name || cmsConfig.id || '',\n      domain: rootConfig.domain || 'https://example.com',\n      base: rootConfig.base || '/',\n      gci: gci,\n      i18n: rootConfig.i18n,\n    },\n    firebaseConfig: options.firebaseConfig,\n    gapi: cmsConfig.gapi,\n    collections: collections,\n  };\n  const projectName = cmsConfig.name || cmsConfig.id || '';\n  const title = projectName ? `${projectName} \u2013 Root.js CMS` : 'Root.js CMS';\n\n  const mainHtml = renderToString(<App title={title} ctx={ctx} />);\n  let html = `<!doctype html>\\n${mainHtml}`;\n  const nonce = generateNonce();\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      .replaceAll('{NONCE}', nonce);\n    html = await req.viteServer!.transformIndexHtml(req.originalUrl, tpl);\n    html = html.replace(\n      '<script type=\"module\" src=\"/@vite/client\"></script>',\n      `<script type=\"module\" src=\"/@vite/client\" nonce=\"${nonce}\"></script>`\n    );\n  } else {\n    html = html\n      .replace('{CSS_URL}', '/cms/static/ui.css')\n      .replace('{JS_URL}', '/cms/static/ui.js')\n      .replaceAll('{NONCE}', nonce);\n  }\n  res.setHeader('Content-Type', 'text/html');\n  setSecurityHeaders(res, nonce);\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        <meta charset=\"utf-8\" />\n        <title>{props.title}</title>\n        <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\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/css?family=Google+Sans:400,500&display=swap\"\n          nonce=\"{NONCE}\"\n        />\n        <link\n          rel=\"icon\"\n          href=\"https://lh3.googleusercontent.com/ijK50TfQlV_yJw3i-CMlnD6osH4PboZBILZrJcWhoNMEmoyCD5e1bAxXbaOPe5w4gG_Scf37EXrmZ6p8sP2lue5fLZ419m5JyLMs=e385-w256\"\n          type=\"image/png\"\n        />\n        <link rel=\"stylesheet\" href=\"{CSS_URL}\" nonce=\"{NONCE}\" />\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          nonce=\"{NONCE}\"\n        />\n        <script type=\"module\" src=\"{JS_URL}\" nonce=\"{NONCE}\"></script>\n      </body>\n    </html>\n  );\n}\nexport async function renderSignIn(req: Request, res: Response, options: any) {\n  const ctx = {name: options.name, firebaseConfig: options.firebaseConfig};\n  const mainHtml = renderToString(<SignIn title=\"Sign in\" ctx={ctx} />);\n  let html = `<!doctype html>\\n${mainHtml}`;\n  const nonce = generateNonce();\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      .replaceAll('{NONCE}', nonce);\n    html = await req.viteServer!.transformIndexHtml(req.originalUrl, tpl);\n    html = html.replace(\n      '<script type=\"module\" src=\"/@vite/client\"></script>',\n      `<script type=\"module\" src=\"/@vite/client\" nonce=\"${nonce}\"></script>`\n    );\n  } else {\n    html = html\n      .replace('{CSS_URL}', '/cms/static/signin.css')\n      .replace('{JS_URL}', '/cms/static/signin.js')\n      .replaceAll('{NONCE}', nonce);\n  }\n  res.setHeader('Content-Type', 'text/html');\n  setSecurityHeaders(res, nonce);\n  res.send(html);\n}\n\nfunction generateNonce() {\n  return crypto.randomBytes(16).toString('base64');\n}\n\nfunction setSecurityHeaders(res: Response, nonce: string) {\n  res.setHeader('x-frame-options', 'SAMEORIGIN');\n  res.setHeader(\n    'strict-transport-security',\n    'max-age=63072000; includeSubdomains; preload'\n  );\n  res.setHeader('x-content-type-options', 'nosniff');\n  res.setHeader('x-xss-protection', '1; mode=block');\n\n  // https://csp.withgoogle.com/docs/strict-csp.html\n  const directives = [\n    \"base-uri 'none'\",\n    \"object-src 'none'\",\n    `script-src 'nonce-${nonce}' 'unsafe-inline' 'unsafe-eval' 'strict-dynamic' https: http:`,\n  ];\n  res.setHeader('content-security-policy-report-only', directives.join(';'));\n}\n"],
  "mappings": "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",
  "names": []
}
