npm - @blinkk/root-cms - Versions diffs - 1.0.0-alpha.26 → 1.0.0-alpha.28 - Mend

@blinkk/root-cms 1.0.0-alpha.26 → 1.0.0-alpha.28

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/app.js ADDED Viewed

@@ -0,0 +1,111 @@
+// core/app.tsx
+import { render as renderToString } from "preact-render-to-string";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { initializeApp } from "firebase-admin/app";
+import { getAuth } from "firebase-admin/auth";
+import { jsx, jsxs } from "preact/jsx-runtime";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var uiCssPath = path.join(__dirname, "ui.css");
+var uiJsPath = path.join(__dirname, "ui.js");
+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: `/@fs${uiCssPath}`
+          })
+        ]
+      }),
+      /* @__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 the CMS 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: `/@fs${uiJsPath}`
+          })
+        ]
+      })
+    ]
+  });
+}
+async function render(req, res) {
+  if (!req.user || !req.user.jwt) {
+    throw new Error("not logged in");
+  }
+  const email = req.user.jwt.email;
+  const uid = req.user.jwt.uid;
+  const app = initializeApp();
+  const auth = getAuth();
+  const customToken = await auth.createCustomToken(uid);
+  const { uid: firebaseUid } = await auth.verifyIdToken(customToken);
+  const token = await auth.createCustomToken(firebaseUid);
+  console.log("custom firebase auth token:");
+  console.log(token);
+  const collectionModules = import.meta.glob("/collections/*.schema.ts", {
+    eager: true
+  });
+  const collections = Object.values(collectionModules).map(
+    (module) => module.default
+  );
+  const ctx = {
+    user: {
+      email,
+      jwt: token
+    },
+    collections
+  };
+  const mainHtml = renderToString(/* @__PURE__ */ jsx(App, {
+    title: "Root.js CMS",
+    ctx
+  }));
+  const html = await req.viteServer.transformIndexHtml(
+    req.originalUrl,
+    `<!doctype html>
+${mainHtml}`
+  );
+  res.setHeader("Content-Type", "text/html");
+  res.send(html);
+}
+export {
+  render
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/core.js ADDED Viewed

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+// core/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  array: () => array,
+  boolean: () => boolean,
+  collection: () => collection,
+  date: () => date,
+  datetime: () => datetime,
+  define: () => define,
+  defineCollection: () => defineCollection,
+  defineSchema: () => defineSchema,
+  image: () => image,
+  multiselect: () => multiselect,
+  number: () => number,
+  object: () => object,
+  oneOf: () => oneOf,
+  select: () => select,
+  string: () => string
+});
+function string(field) {
+  return { ...field, type: "string" };
+}
+function number(field) {
+  return { ...field, type: "number" };
+}
+function date(field) {
+  return { ...field, type: "date" };
+}
+function datetime(field) {
+  return { ...field, type: "datetime" };
+}
+function boolean(field) {
+  return { ...field, type: "boolean" };
+}
+function select(field) {
+  return { ...field, type: "select" };
+}
+function multiselect(field) {
+  return { ...field, type: "multiselect" };
+}
+function image(field) {
+  return { ...field, type: "image" };
+}
+function object(field) {
+  return { ...field, type: "object" };
+}
+function array(field) {
+  return { ...field, type: "array" };
+}
+function oneOf(field) {
+  return { ...field, type: "oneof" };
+}
+function defineSchema(schema) {
+  return schema;
+}
+var define = defineSchema;
+function defineCollection(collection2) {
+  return collection2;
+}
+var collection = defineCollection;
+export {
+  schema_exports as schema
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts CHANGED Viewed

@@ -1,3 +1,163 @@
-declare const test: {};
+import { FunctionalComponent } from 'preact';
-export { test };
+interface CommonFieldProps {
+    id?: string;
+    label?: string;
+    help?: string;
+    type: string;
+    default?: any;
+    hidden?: boolean;
+    deprecated?: boolean;
+}
+type StringField = CommonFieldProps & {
+    type: 'string';
+    default?: string;
+    translate?: boolean;
+    variant?: 'input' | 'textarea';
+};
+declare function string(field: Omit<StringField, 'type'>): StringField;
+type NumberField = CommonFieldProps & {
+    type: 'number';
+    default?: number;
+};
+declare function number(field: Omit<NumberField, 'type'>): NumberField;
+type DateField = CommonFieldProps & {
+    type: 'date';
+    default?: string;
+};
+declare function date(field: Omit<DateField, 'type'>): DateField;
+type DateTimeField = CommonFieldProps & {
+    type: 'datetime';
+    default?: string;
+};
+declare function datetime(field: Omit<DateTimeField, 'type'>): DateTimeField;
+type BooleanField = CommonFieldProps & {
+    type: 'boolean';
+    default?: boolean;
+};
+declare function boolean(field: Omit<BooleanField, 'type'>): BooleanField;
+type SelectField = CommonFieldProps & {
+    type: 'select';
+    default?: string;
+    options?: {
+        values?: Array<{
+            value: string;
+            label?: string;
+        }>;
+    };
+};
+declare function select(field: Omit<SelectField, 'type'>): SelectField;
+type MultiSelectField = Omit<SelectField, 'type'> & {
+    type: 'multiselect';
+    default?: string[];
+};
+declare function multiselect(field: Omit<MultiSelectField, 'type'>): MultiSelectField;
+type ImageField = CommonFieldProps & {
+    type: 'image';
+};
+declare function image(field: Omit<ImageField, 'type'>): ImageField;
+type ObjectField = CommonFieldProps & {
+    type: 'object';
+    fields: FieldWithId[];
+};
+declare function object(field: Omit<ObjectField, 'type'>): ObjectField;
+type ArrayField = CommonFieldProps & {
+    type: 'array';
+    default?: Array<any>;
+    preview?: (value: any) => string;
+    of: ImageField | ObjectField | OneOfField;
+};
+declare function array(field: Omit<ArrayField, 'type'>): ArrayField;
+type OneOfField = CommonFieldProps & {
+    type: 'oneof';
+    types: Array<Schema>;
+};
+declare function oneOf(field: Omit<OneOfField, 'type'>): OneOfField;
+type Field = StringField | NumberField | DateField | DateTimeField | BooleanField | SelectField | MultiSelectField | ImageField | ObjectField | ArrayField | OneOfField;
+type FieldWithId = Field;
+interface Schema {
+    name: string;
+    description?: string;
+    fields: Array<FieldWithId>;
+}
+declare function defineSchema(schema: Schema): Schema;
+declare const define: typeof defineSchema;
+type Collection = Schema & {
+    url?: string;
+    Component: FunctionalComponent;
+    preview?: {
+        title?: string;
+        image?: string;
+    };
+};
+declare function defineCollection(collection: Collection): Collection;
+declare const collection: typeof defineCollection;
+type schema_CommonFieldProps = CommonFieldProps;
+type schema_StringField = StringField;
+declare const schema_string: typeof string;
+type schema_NumberField = NumberField;
+declare const schema_number: typeof number;
+type schema_DateField = DateField;
+declare const schema_date: typeof date;
+type schema_DateTimeField = DateTimeField;
+declare const schema_datetime: typeof datetime;
+type schema_BooleanField = BooleanField;
+declare const schema_boolean: typeof boolean;
+type schema_SelectField = SelectField;
+declare const schema_select: typeof select;
+type schema_MultiSelectField = MultiSelectField;
+declare const schema_multiselect: typeof multiselect;
+type schema_ImageField = ImageField;
+declare const schema_image: typeof image;
+type schema_ObjectField = ObjectField;
+declare const schema_object: typeof object;
+type schema_ArrayField = ArrayField;
+declare const schema_array: typeof array;
+type schema_OneOfField = OneOfField;
+declare const schema_oneOf: typeof oneOf;
+type schema_Field = Field;
+type schema_FieldWithId = FieldWithId;
+type schema_Schema = Schema;
+declare const schema_defineSchema: typeof defineSchema;
+declare const schema_define: typeof define;
+type schema_Collection = Collection;
+declare const schema_defineCollection: typeof defineCollection;
+declare const schema_collection: typeof collection;
+declare namespace schema {
+  export {
+    schema_CommonFieldProps as CommonFieldProps,
+    schema_StringField as StringField,
+    schema_string as string,
+    schema_NumberField as NumberField,
+    schema_number as number,
+    schema_DateField as DateField,
+    schema_date as date,
+    schema_DateTimeField as DateTimeField,
+    schema_datetime as datetime,
+    schema_BooleanField as BooleanField,
+    schema_boolean as boolean,
+    schema_SelectField as SelectField,
+    schema_select as select,
+    schema_MultiSelectField as MultiSelectField,
+    schema_multiselect as multiselect,
+    schema_ImageField as ImageField,
+    schema_image as image,
+    schema_ObjectField as ObjectField,
+    schema_object as object,
+    schema_ArrayField as ArrayField,
+    schema_array as array,
+    schema_OneOfField as OneOfField,
+    schema_oneOf as oneOf,
+    schema_Field as Field,
+    schema_FieldWithId as FieldWithId,
+    schema_Schema as Schema,
+    schema_defineSchema as defineSchema,
+    schema_define as define,
+    schema_Collection as Collection,
+    schema_defineCollection as defineCollection,
+    schema_collection as collection,
+  };
+}
+export { schema };

package/dist/plugin.d.ts CHANGED Viewed

@@ -1,6 +1,14 @@
-import { Plugin } from '@blinkk/root';
+import { Request, Plugin } from '@blinkk/root';
-declare type CMSPluginOptions = {};
+interface User {
+    email: string;
+    jwt: any;
+}
+type CMSPluginOptions = {
+    cookieSecret?: string | string[];
+    isUserAuthorized?: (req: Request, user: User) => boolean | Promise<boolean>;
+};
 declare function cmsPlugin(options?: CMSPluginOptions): Plugin;
-export { cmsPlugin };
+export { CMSPluginOptions, cmsPlugin };

package/dist/plugin.js CHANGED Viewed

@@ -1,17 +1,196 @@
-// src/plugin.ts
+// core/users.ts
+import jsonwebtoken from "jsonwebtoken";
+var AUTH_COOKIE = "ROOTJS_AUTH";
+function usersMiddleware(options) {
+  const clientId = process.env.GOOGLE_CLIENT_ID;
+  const clientSecret = process.env.GOOGLE_CLIENT_SECRET;
+  const loginUrl = options.loginUrl || "/cms/login";
+  if (!clientId || !clientSecret) {
+    throw new Error(
+      "Missing one or more required .env vars: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET"
+    );
+  }
+  function isLoginRequired(req) {
+    if (!options.isLoginRequired) {
+      return false;
+    }
+    return options.isLoginRequired(req);
+  }
+  function isUserAuthorized(req, user) {
+    if (!options.isUserAuthorized) {
+      return true;
+    }
+    return options.isUserAuthorized(req, user);
+  }
+  function getLoginUrl(req) {
+    const params = new URLSearchParams();
+    params.set("scope", "email");
+    params.set("access_type", "online");
+    params.set("client_id", clientId);
+    params.set("redirect_uri", getRedirectUrl(req));
+    params.set("state", req.originalUrl);
+    params.set("response_type", "code");
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+  function getRedirectUrl(req) {
+    const host = getHost(req);
+    const protocol = req.protocol;
+    return `${protocol}://${host}${loginUrl}`;
+  }
+  function getHost(req) {
+    return req.headers["x-forwarded-host"] || req.headers.host;
+  }
+  function loginRedirect(req, res) {
+    const loginUrl2 = getLoginUrl(req);
+    res.redirect(loginUrl2);
+    return;
+  }
+  async function getOAuthToken(req, code) {
+    const params = new URLSearchParams();
+    params.set("client_id", clientId);
+    params.set("client_secret", clientSecret);
+    params.set("redirect_uri", getRedirectUrl(req));
+    params.set("grant_type", "authorization_code");
+    params.set("code", code);
+    const res = await fetch("https://oauth2.googleapis.com/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: params.toString()
+    });
+    if (res.status !== 200) {
+      console.error(res.status);
+      throw new Error("failed to retrieve jwt token");
+    }
+    return res.json();
+  }
+  async function getUser(req) {
+    const cookieValue = req.signedCookies[AUTH_COOKIE];
+    console.log(cookieValue);
+    if (cookieValue) {
+      try {
+        const jwt = decodeJWT(cookieValue);
+        if (jwt && jwt.email) {
+          return {
+            email: jwt.email,
+            jwt
+          };
+        }
+      } catch (e) {
+        console.error(`failed to parse jwt: ${cookieValue}`);
+        console.error(e);
+      }
+    }
+    return null;
+  }
+  async function handleLogin(req, res) {
+    const code = req.query.code;
+    if (!code) {
+      res.status(403).send("Missing required param: code");
+      return;
+    }
+    const token = await getOAuthToken(req, code);
+    const jwt = decodeJWT(token.id_token);
+    if (!jwt || !jwt.email || !jwt.email_verified) {
+      res.status(500).send("500: Login failed");
+      return;
+    }
+    const exp = jwt.exp || Math.floor(new Date().getTime() / 1e3 + 3600);
+    res.cookie(AUTH_COOKIE, token.id_token, {
+      secure: req.hostname !== "localhost",
+      httpOnly: true,
+      sameSite: true,
+      expires: new Date(exp * 1e3),
+      signed: true
+    });
+    const state = String(req.params.state);
+    if (state && state.startsWith("/cms")) {
+      res.redirect(state);
+    } else {
+      res.redirect("/cms");
+    }
+  }
+  function decodeJWT(token) {
+    try {
+      const decoded = jsonwebtoken.decode(token, { complete: true });
+      return decoded == null ? void 0 : decoded.payload;
+    } catch (err) {
+      return null;
+    }
+  }
+  return async (req, res, next) => {
+    try {
+      if (req.originalUrl.startsWith(loginUrl)) {
+        await handleLogin(req, res);
+        return;
+      }
+      const user = await getUser(req);
+      if (isLoginRequired(req)) {
+        if (!user) {
+          loginRedirect(req, res);
+          return;
+        }
+        if (!isUserAuthorized(req, user)) {
+          res.status(403).send("403: Login failed");
+          return;
+        }
+      }
+      const r = req;
+      r.user = user;
+      next();
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+// core/plugin.ts
+import cookieParser from "cookie-parser";
+import * as dotenv from "dotenv";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config();
+function generateSecret() {
+  const result = [];
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  for (let i = 0; i < 36; i++) {
+    const rand = Math.floor(Math.random() * chars.length);
+    result.push(chars.charAt(rand));
+  }
+  return result.join("");
+}
 function cmsPlugin(options) {
+  const cookieSecret = (options == null ? void 0 : options.cookieSecret) || generateSecret();
   return {
     name: "root-cms",
     configureServer: (server) => {
-      server.use("/cms", (req, res) => {
-        console.log("root config context var:");
-        console.log(req.rootConfig);
-        res.end("cms");
-      });
+      server.use("/cms", cookieParser(cookieSecret));
+      server.use(
+        "/cms",
+        usersMiddleware({
+          isLoginRequired: () => true,
+          isUserAuthorized: options == null ? void 0 : options.isUserAuthorized
+        })
+      );
+      server.use(
+        "/cms",
+        async (req, res, next) => {
+          try {
+            const appPath = path.resolve(__dirname, "./app.js");
+            const app = await req.viteServer.ssrLoadModule(appPath);
+            app.render(req, res);
+          } catch (err) {
+            console.error(err);
+            next(err);
+          }
+        }
+      );
     }
   };
 }
 export {
   cmsPlugin
 };
-//# sourceMappingURL=plugin.js.map
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../core/users.ts", "../core/plugin.ts"],
  "sourcesContent": ["import {NextFunction, Request, Response} from '@blinkk/root';\nimport jsonwebtoken from 'jsonwebtoken';\n\nexport interface User {\n  email: string;\n  jwt: any;\n}\n\nexport type UserRequest = Request & {\n  user?: User | null;\n};\n\nexport interface MiddlewareOptions {\n  isLoginRequired?: (req: Request) => boolean;\n  isUserAuthorized?: (req: Request, user: User) => boolean | Promise<boolean>;\n  loginUrl?: string;\n}\n\nconst AUTH_COOKIE = 'ROOTJS_AUTH';\n\nexport function usersMiddleware(options: MiddlewareOptions) {\n  const clientId = process.env.GOOGLE_CLIENT_ID!;\n  const clientSecret = process.env.GOOGLE_CLIENT_SECRET!;\n  const loginUrl = options.loginUrl || '/cms/login';\n\n  if (!clientId || !clientSecret) {\n    throw new Error(\n      'Missing one or more required .env vars: GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET'\n    );\n  }\n\n  function isLoginRequired(req: Request) {\n    if (!options.isLoginRequired) {\n      return false;\n    }\n    return options.isLoginRequired(req);\n  }\n\n  function isUserAuthorized(req: Request, user: User) {\n    if (!options.isUserAuthorized) {\n      return true;\n    }\n    return options.isUserAuthorized(req, user);\n  }\n\n  function getLoginUrl(req: Request) {\n    const params = new URLSearchParams();\n    params.set('scope', 'email');\n    params.set('access_type', 'online');\n    params.set('client_id', clientId);\n    params.set('redirect_uri', getRedirectUrl(req));\n    params.set('state', req.originalUrl);\n    params.set('response_type', 'code');\n    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;\n  }\n\n  function getRedirectUrl(req: Request) {\n    const host = getHost(req);\n    const protocol = req.protocol;\n    return `${protocol}://${host}${loginUrl}`;\n  }\n\n  function getHost(req: Request) {\n    return req.headers['x-forwarded-host'] || req.headers.host;\n  }\n\n  function loginRedirect(req: Request, res: Response) {\n    const loginUrl = getLoginUrl(req);\n    res.redirect(loginUrl);\n    return;\n  }\n\n  async function getOAuthToken(req: Request, code: string) {\n    const params = new URLSearchParams();\n    params.set('client_id', clientId);\n    params.set('client_secret', clientSecret);\n    params.set('redirect_uri', getRedirectUrl(req));\n    params.set('grant_type', 'authorization_code');\n    params.set('code', code);\n\n    const res = await fetch('https://oauth2.googleapis.com/token', {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n      },\n      body: params.toString(),\n    });\n    if (res.status !== 200) {\n      console.error(res.status);\n      throw new Error('failed to retrieve jwt token');\n    }\n    return res.json();\n  }\n\n  async function getUser(req: Request): Promise<User | null> {\n    const cookieValue = req.signedCookies[AUTH_COOKIE];\n    console.log(cookieValue);\n    if (cookieValue) {\n      try {\n        const jwt = decodeJWT(cookieValue);\n        if (jwt && jwt.email) {\n          return {\n            email: jwt.email,\n            jwt: jwt,\n          };\n        }\n      } catch (e) {\n        console.error(`failed to parse jwt: ${cookieValue}`);\n        console.error(e);\n      }\n    }\n    return null;\n  }\n\n  async function handleLogin(req: Request, res: Response) {\n    const code = req.query.code as string;\n    if (!code) {\n      res.status(403).send('Missing required param: code');\n      return;\n    }\n    const token = await getOAuthToken(req, code);\n    const jwt = decodeJWT(token.id_token);\n    if (!jwt || !jwt.email || !jwt.email_verified) {\n      res.status(500).send('500: Login failed');\n      return;\n    }\n    const exp = jwt.exp || Math.floor(new Date().getTime() / 1000 + 3600);\n    res.cookie(AUTH_COOKIE, token.id_token, {\n      secure: req.hostname !== 'localhost',\n      httpOnly: true,\n      sameSite: true,\n      expires: new Date(exp * 1000),\n      signed: true,\n    });\n    const state = String(req.params.state);\n    if (state && state.startsWith('/cms')) {\n      res.redirect(state);\n    } else {\n      res.redirect('/cms');\n    }\n  }\n\n  function decodeJWT(token: string) {\n    try {\n      const decoded = jsonwebtoken.decode(token, {complete: true});\n      return decoded?.payload as jsonwebtoken.JwtPayload;\n    } catch (err) {\n      return null;\n    }\n  }\n\n  return async (req: Request, res: Response, next: NextFunction) => {\n    try {\n      if (req.originalUrl.startsWith(loginUrl)) {\n        await handleLogin(req, res);\n        return;\n      }\n      const user = await getUser(req);\n      if (isLoginRequired(req)) {\n        if (!user) {\n          loginRedirect(req, res);\n          return;\n        }\n        if (!isUserAuthorized(req, user)) {\n          res.status(403).send('403: Login failed');\n          return;\n        }\n      }\n      const r = req as UserRequest;\n      r.user = user;\n      next();\n    } catch (err) {\n      next(err);\n    }\n  };\n}\n", "import {NextFunction, Plugin, Request, Response} from '@blinkk/root';\nimport {User, usersMiddleware} from './users.js';\nimport cookieParser from 'cookie-parser';\nimport * as dotenv from 'dotenv';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\ndotenv.config();\n\nexport type CMSPluginOptions = {\n  // Secret value(s) used for signing the user authentication cookie.\n  cookieSecret?: string | string[];\n  // Function called to check if a user should have access to the CMS.\n  isUserAuthorized?: (req: Request, user: User) => boolean | Promise<boolean>;\n};\n\nfunction generateSecret(): string {\n  const result = [];\n  const chars =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  for (let i = 0; i < 36; i++) {\n    const rand = Math.floor(Math.random() * chars.length);\n    result.push(chars.charAt(rand));\n  }\n  return result.join('');\n}\n\nexport function cmsPlugin(options?: CMSPluginOptions): Plugin {\n  const cookieSecret = options?.cookieSecret || generateSecret();\n  return {\n    name: 'root-cms',\n    configureServer: (server) => {\n      server.use('/cms', cookieParser(cookieSecret));\n      server.use(\n        '/cms',\n        usersMiddleware({\n          isLoginRequired: () => true,\n          isUserAuthorized: options?.isUserAuthorized,\n        })\n      );\n      // server.use('/cms/main.js', async (req: Request, res: Response) => {\n      //   const viteServer = req.viteServer!;\n      //   const appPath = path.resolve(__dirname, './app.js');\n      //   const fileUrl = path.join('/@fs', appPath.slice(1));\n      //   console.log(fileUrl);\n      //   const val = await viteServer.transformRequest(\n      //     path.join('/@fs', appPath.slice(1))\n      //   );\n      //   if (val?.code) {\n      //     res.setHeader('content-type', 'text/plain');\n      //     res.send(val.code);\n      //   } else {\n      //     res.send('not found');\n      //   }\n      // });\n      server.use(\n        '/cms',\n        async (req: Request, res: Response, next: NextFunction) => {\n          try {\n            const appPath = path.resolve(__dirname, './app.js');\n            const app = await req.viteServer!.ssrLoadModule(appPath);\n            app.render(req, res);\n          } catch (err) {\n            console.error(err);\n            next(err);\n          }\n        }\n      );\n    },\n  };\n}\n"],
  "mappings": "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",
  "names": ["loginUrl"]
}
