studiocms 0.1.0-beta.10

package/dist/utils/configResolver.js

@@ -0,0 +1,105 @@
+import { defineUtility } from "astro-integration-kit";
+import { z } from "astro/zod";
+import lo from "lodash";
+import { StudioCMSCoreError } from "../errors.js";
+import {
+  StudioCMSOptionsSchema
+} from "../schemas/index.js";
+import { loadStudioCMSConfigFile } from "./configManager.js";
+function parseConfig(opts) {
+  try {
+    return StudioCMSOptionsSchema.parse(opts);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new StudioCMSCoreError(
+        `Invalid StudioCMS Config Options: ${error.message}`,
+        error.stack
+      );
+    }
+    throw new StudioCMSCoreError(
+      "Invalid StudioCMS Options",
+      "An unknown error occurred while parsing the StudioCMS options."
+    );
+  }
+}
+function deepRemoveDefaults(schema) {
+  if (schema instanceof z.ZodDefault) return deepRemoveDefaults(schema.removeDefault());
+  if (schema instanceof z.ZodObject) {
+    const newShape = {};
+    for (const key in schema.shape) {
+      const fieldSchema = schema.shape[key];
+      newShape[key] = z.ZodOptional.create(deepRemoveDefaults(fieldSchema));
+    }
+    return new z.ZodObject({
+      ...schema._def,
+      shape: () => newShape
+      // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    });
+  }
+  if (schema instanceof z.ZodArray) return z.ZodArray.create(deepRemoveDefaults(schema.element));
+  if (schema instanceof z.ZodOptional)
+    return z.ZodOptional.create(deepRemoveDefaults(schema.unwrap()));
+  if (schema instanceof z.ZodNullable)
+    return z.ZodNullable.create(deepRemoveDefaults(schema.unwrap()));
+  if (schema instanceof z.ZodTuple)
+    return z.ZodTuple.create(schema.items.map((item) => deepRemoveDefaults(item)));
+  return schema;
+}
+function parseAndMerge(schema, inlineConfig, studioCMSConfigFile) {
+  try {
+    const ZeroDefaultsSchema = deepRemoveDefaults(schema);
+    const parsedConfigFile = ZeroDefaultsSchema.parse(studioCMSConfigFile);
+    return lo.merge({}, inlineConfig, parsedConfigFile);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new StudioCMSCoreError(
+        `Invalid StudioCMS Config Options: ${error.message}`,
+        error.stack
+      );
+    }
+    throw new StudioCMSCoreError(
+      "Invalid StudioCMS Options",
+      "An unknown error occurred while parsing the StudioCMS options."
+    );
+  }
+}
+const configResolver = defineUtility("astro:config:setup")(
+  async (params, options) => {
+    const { logger: l, config: astroConfig } = params;
+    const logger = l.fork("studiocms:config");
+    const inlineConfigExists = options !== void 0;
+    const inlineConfig = parseConfig(options);
+    const studioCMSConfigFile = await loadStudioCMSConfigFile(astroConfig.root);
+    if (!studioCMSConfigFile) {
+      return inlineConfig;
+    }
+    try {
+      if (inlineConfigExists) {
+        logger.warn(
+          "Both an inline StudioCMS config (in your Astro config file) and a StudioCMS config file (studiocms.config.{js|mjs|cjs|ts|mts|cts}) were found. The StudioCMS config file will override the inline config during merging."
+        );
+      }
+      const mergedOptions = parseAndMerge(
+        StudioCMSOptionsSchema,
+        inlineConfig,
+        studioCMSConfigFile
+      );
+      return mergedOptions;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new StudioCMSCoreError(
+          `Invalid StudioCMS Config Options: ${error.message}`,
+          error.stack
+        );
+      }
+      throw new StudioCMSCoreError(
+        "Invalid StudioCMS Options",
+        "An unknown error occurred while parsing the StudioCMS options."
+      );
+    }
+  }
+);
+export {
+  configResolver,
+  parseConfig
+};

package/dist/utils/defineStudioCMSConfig.d.ts

@@ -0,0 +1,165 @@
+import type { StudioCMSOptions } from '../schemas/index.js';
+/**
+ * A utility function to define the StudioCMS config object.
+ * This function is used to define the optional StudioCMS
+ * config object in the Astro project root. The expected file
+ * name is `studiocms.config.mjs`. And it should be adjacent
+ * to the Astro project's `astro.config.mjs` file.
+ *
+ * StudioCMS will attempt to import this file and use the default
+ * export as the StudioCMS config object automatically if it exists.
+ *
+ * Using this function is optional, but it can be useful for IDEs
+ * to provide better intellisense and type checking.
+ *
+ * @example
+ * ```js
+ * // studiocms.config.mjs
+ * import { defineStudioCMSConfig } from 'studiocms';
+ *
+ * export default defineStudioCMSConfig({
+ *  dbStartPage: true,
+ *  contentRenderer: 'marked',
+ *  verbose: true,
+ *  dateLocale: 'en-us',
+ *  // ...Other Options
+ * })
+ * ```
+ *
+ */
+export declare function defineStudioCMSConfig(config: StudioCMSOptions): {
+    dbStartPage?: boolean | undefined;
+    rendererConfig?: {
+        studiocms?: false | {
+            callouts?: false | {
+                theme?: "github" | "obsidian" | "vitepress" | undefined;
+            } | undefined;
+            autoLinkHeadings?: boolean | undefined;
+            discordSubtext?: boolean | undefined;
+            sanitize?: {
+                allowElements?: string[] | undefined;
+                blockElements?: string[] | undefined;
+                dropElements?: string[] | undefined;
+                allowAttributes?: Record<string, string[]> | undefined;
+                dropAttributes?: Record<string, string[]> | undefined;
+                allowComponents?: boolean | undefined;
+                allowCustomElements?: boolean | undefined;
+                allowComments?: boolean | undefined;
+            } | undefined;
+        } | undefined;
+        renderer?: "studiocms" | import("../config.js").CustomRenderer | "astro" | "markdoc" | "mdx" | undefined;
+        markdocConfig?: {
+            renderType?: "html" | import("../schemas/config/markdoc.js").MarkdocRenderer | "react-static" | undefined;
+            argParse?: {
+                file?: string | undefined;
+                slots?: boolean | undefined;
+                location?: boolean | undefined;
+            } | undefined;
+            transformConfig?: {
+                tags?: Record<string, {}> | undefined;
+                validation?: {
+                    parents?: any[] | undefined;
+                    validateFunctions?: boolean | undefined;
+                    environment?: string | undefined;
+                } | undefined;
+                nodes?: Record<string, {}> | undefined;
+                variables?: Record<string, any> | undefined;
+                functions?: Record<string, any> | undefined;
+                partials?: Record<string, any> | undefined;
+            } | undefined;
+        } | undefined;
+        mdxConfig?: {
+            remarkPlugins?: import("unified").PluggableList | undefined;
+            rehypePlugins?: import("unified").PluggableList | undefined;
+            recmaPlugins?: import("unified").PluggableList | undefined;
+            remarkRehypeOptions?: {
+                file?: any;
+                allowDangerousHtml?: boolean | null | undefined;
+                clobberPrefix?: string | null | undefined;
+                footnoteBackContent?: string | ((args_0: number, args_1: number, ...args: unknown[]) => string | {
+                    type: "comment";
+                    value: string;
+                } | {
+                    type: "element";
+                    children: any[];
+                    tagName: string;
+                    properties: Record<string, any>;
+                } | {
+                    type: "text";
+                    value: string;
+                } | ({
+                    type: "comment";
+                    value: string;
+                } | {
+                    type: "element";
+                    children: any[];
+                    tagName: string;
+                    properties: Record<string, any>;
+                } | {
+                    type: "text";
+                    value: string;
+                })[]) | null | undefined;
+                footnoteBackLabel?: string | ((args_0: number, args_1: number, ...args: unknown[]) => string) | null | undefined;
+                footnoteLabel?: string | null | undefined;
+                footnoteLabelProperties?: Record<string, string | number | boolean | (string | number)[] | null | undefined> | null | undefined;
+                footnoteLabelTagName?: string | null | undefined;
+                handlers?: any;
+                passThrough?: string[] | null | undefined;
+                unknownHandler?: any;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    imageService?: {
+        cdnPlugin?: "cloudinary-js" | undefined;
+    } | undefined;
+    defaultFrontEndConfig?: boolean | {
+        htmlDefaultLanguage?: string | undefined;
+        htmlDefaultHead?: {
+            tag: "base" | "link" | "meta" | "noscript" | "script" | "style" | "template" | "title";
+            content?: string | undefined;
+            attrs?: Record<string, string | boolean | undefined> | undefined;
+        }[] | undefined;
+        favicon?: string | undefined;
+        injectQuickActionsMenu?: boolean | undefined;
+    } | undefined;
+    dashboardConfig?: {
+        dashboardEnabled?: boolean | undefined;
+        inject404Route?: boolean | undefined;
+        faviconURL?: string | undefined;
+        dashboardRouteOverride?: string | undefined;
+        AuthConfig?: {
+            providers?: {
+                github?: boolean | undefined;
+                discord?: boolean | undefined;
+                google?: boolean | undefined;
+                auth0?: boolean | undefined;
+                usernameAndPassword?: boolean | undefined;
+                usernameAndPasswordConfig?: {
+                    allowUserRegistration?: boolean | undefined;
+                } | undefined;
+            } | undefined;
+            enabled?: boolean | undefined;
+        } | undefined;
+        developerConfig?: {
+            testingAndDemoMode?: boolean | undefined;
+        } | undefined;
+        versionCheck?: boolean | undefined;
+    } | undefined;
+    includedIntegrations?: {
+        robotsTXT?: boolean | import("../lib/robots/types.js").RobotsConfig | undefined;
+    } | undefined;
+    dateLocale?: string | undefined;
+    dateTimeFormat?: Intl.DateTimeFormatOptions | undefined;
+    overrides?: {
+        CustomImageOverride?: string | undefined;
+        FormattedDateOverride?: string | undefined;
+    } | undefined;
+    verbose?: boolean | undefined;
+    plugins?: import("../plugins.js").StudioCMSPlugin[] | undefined;
+    sdk?: boolean | {
+        cacheConfig?: boolean | {
+            lifetime?: string | undefined;
+        } | undefined;
+    } | undefined;
+    componentRegistry?: Record<string, string> | undefined;
+} | undefined;

package/dist/utils/defineStudioCMSConfig.js

@@ -0,0 +1,6 @@
+function defineStudioCMSConfig(config) {
+  return config;
+}
+export {
+  defineStudioCMSConfig
+};

package/dist/utils/getLabelForPermissionLevel.d.ts

@@ -0,0 +1,2 @@
+declare const getLabelForPermissionLevel: (permissionLevel: "admin" | "editor" | "owner" | "visitor" | string) => "Administrator" | "Editor" | "Owner" | "Visitor" | "Unknown";
+export { getLabelForPermissionLevel };

package/dist/utils/getLabelForPermissionLevel.js

@@ -0,0 +1,17 @@
+const getLabelForPermissionLevel = (permissionLevel) => {
+  switch (permissionLevel) {
+    case "admin":
+      return "Administrator";
+    case "editor":
+      return "Editor";
+    case "owner":
+      return "Owner";
+    case "visitor":
+      return "Visitor";
+    default:
+      return "Unknown";
+  }
+};
+export {
+  getLabelForPermissionLevel
+};

package/dist/utils/injectRouteArray.d.ts

@@ -0,0 +1,19 @@
+import type { StudioCMSConfig } from '../schemas/index.js';
+export declare const injectRouteArray: import("astro-integration-kit").HookUtility<"astro:config:setup", [opts: {
+    options: StudioCMSConfig;
+    routes: {
+        enabled: boolean;
+        pattern: string;
+        entrypoint: string;
+        _non_dashboard?: boolean;
+    }[];
+}], void>;
+export declare const injectDashboardRoute: import("astro-integration-kit").HookUtility<"astro:config:setup", [opts: {
+    options: StudioCMSConfig;
+    routes: {
+        enabled: boolean;
+        pattern: string;
+        entrypoint: string;
+        prerender?: boolean;
+    }[];
+}, prerenderRoutes: boolean], void>;

package/dist/utils/injectRouteArray.js

@@ -0,0 +1,75 @@
+import { defineUtility } from "astro-integration-kit";
+import { removeLeadingTrailingSlashes } from "../lib/index.js";
+import { integrationLogger } from "./integrationLogger.js";
+const injectRouteArray = defineUtility("astro:config:setup")(
+  (params, opts) => {
+    const { injectRoute } = params;
+    const {
+      options: {
+        dashboardConfig: { dashboardRouteOverride }
+      },
+      routes
+    } = opts;
+    const defaultDashboardRoute = dashboardRouteOverride ? removeLeadingTrailingSlashes(dashboardRouteOverride) : "dashboard";
+    const makeDashboardRoute = (path) => {
+      return `${defaultDashboardRoute}/${path}`;
+    };
+    for (const route of routes) {
+      const { enabled, _non_dashboard, pattern, entrypoint } = route;
+      if (enabled) {
+        if (_non_dashboard) {
+          injectRoute({
+            pattern,
+            entrypoint
+          });
+        } else {
+          injectRoute({
+            pattern: makeDashboardRoute(pattern),
+            entrypoint
+          });
+        }
+      }
+    }
+  }
+);
+const injectDashboardRoute = defineUtility("astro:config:setup")(
+  (params, opts, prerenderRoutes) => {
+    const { injectRoute, logger } = params;
+    const {
+      options: {
+        verbose,
+        dashboardConfig: { dashboardRouteOverride, dashboardEnabled }
+      },
+      routes
+    } = opts;
+    if (dashboardEnabled) {
+      integrationLogger({ logger, logLevel: "info", verbose }, "Injecting Page Routes...");
+      let defaultDashboardRoute = dashboardRouteOverride ? removeLeadingTrailingSlashes(dashboardRouteOverride) : "dashboard";
+      if (defaultDashboardRoute === "/") {
+        defaultDashboardRoute = "";
+      }
+      const makeDashboardRoute = (path) => {
+        return `${defaultDashboardRoute}/${path}`;
+      };
+      for (const route of routes) {
+        const { enabled, pattern, entrypoint, prerender = prerenderRoutes } = route;
+        if (enabled) {
+          injectRoute({
+            pattern: makeDashboardRoute(pattern),
+            entrypoint,
+            prerender
+          });
+        }
+      }
+    } else {
+      integrationLogger(
+        { logger, logLevel: "info", verbose },
+        "Dashboard is Disabled, Some tools and Utilities are still available for developers who are customizing their setup!"
+      );
+    }
+  }
+);
+export {
+  injectDashboardRoute,
+  injectRouteArray
+};

package/dist/utils/integrationLogger.d.ts

@@ -0,0 +1,7 @@
+import type { AstroIntegrationLogger } from 'astro';
+export type LoggerOpts = {
+    logLevel: 'info' | 'warn' | 'error' | 'debug';
+    logger: AstroIntegrationLogger;
+    verbose?: boolean;
+};
+export declare const integrationLogger: (opts: LoggerOpts, message: string) => Promise<void>;

package/dist/utils/integrationLogger.js

@@ -0,0 +1,18 @@
+const integrationLogger = async (opts, message) => {
+  const { logLevel, logger, verbose } = opts;
+  switch (verbose) {
+    case true:
+      logger[logLevel](message);
+      break;
+    case false:
+      if (logLevel !== "debug" && logLevel !== "info") {
+        logger[logLevel](message);
+      }
+      break;
+    default:
+      logger[logLevel](message);
+  }
+};
+export {
+  integrationLogger
+};

package/dist/utils/integrations.d.ts

@@ -0,0 +1,4 @@
+import type { AstroIntegration } from 'astro';
+import type { PluginOption } from 'vite';
+export declare function namespaceBuiltinsPlugin(): PluginOption;
+export declare function nodeNamespaceBuiltinsAstro(): AstroIntegration;

package/dist/utils/integrations.js

@@ -0,0 +1,32 @@
+import { builtinModules as builtins } from "node:module";
+import { addVitePlugin, hasVitePlugin } from "astro-integration-kit";
+function namespaceBuiltinsPlugin() {
+  return {
+    name: "namespace-builtins",
+    enforce: "pre",
+    // biome-ignore lint/suspicious/noExplicitAny: This is a Vite plugin, so we don't have control over the type of `id`
+    resolveId(id) {
+      if (id[0] === "." || id[0] === "/") return;
+      if (builtins.includes(id)) {
+        return { id: `node:${id}`, external: true };
+      }
+      return;
+    }
+  };
+}
+function nodeNamespaceBuiltinsAstro() {
+  return {
+    name: "vite-namespace-builtins",
+    hooks: {
+      "astro:config:setup": (params) => {
+        if (!hasVitePlugin(params, { plugin: "namespace-builtins" })) {
+          addVitePlugin(params, { plugin: namespaceBuiltinsPlugin() });
+        }
+      }
+    }
+  };
+}
+export {
+  namespaceBuiltinsPlugin,
+  nodeNamespaceBuiltinsAstro
+};

package/dist/utils/isDashboardRoute.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a route is a dashboard route
+ *
+ * @param {string} pageRoute - The route to check if it is a dashboard route
+ * @returns {boolean} - Returns true if the route is a dashboard route
+ */
+export declare const isDashboardRoute: (pageRoute: string) => boolean;

package/dist/utils/isDashboardRoute.js

@@ -0,0 +1,10 @@
+import { dashboardConfig } from "studiocms:config";
+import { removeLeadingTrailingSlashes } from "studiocms:lib";
+const { dashboardRouteOverride } = dashboardConfig;
+const dashboardURL = dashboardRouteOverride ? removeLeadingTrailingSlashes(dashboardRouteOverride) : "dashboard";
+const isDashboardRoute = (pageRoute) => {
+  return removeLeadingTrailingSlashes(pageRoute).includes(dashboardURL);
+};
+export {
+  isDashboardRoute
+};

package/dist/utils/makePageTitle.d.ts

@@ -0,0 +1,3 @@
+export declare const makePageTitle: (pageName: string, config: {
+    title: string;
+}, separator?: string) => string;

package/dist/utils/makePageTitle.js

@@ -0,0 +1,7 @@
+const makePageTitle = (pageName, config, separator) => {
+  const separatorString = separator ? `${separator}` : "|";
+  return `${pageName} ${separatorString} ${config.title}`;
+};
+export {
+  makePageTitle
+};

package/dist/utils/pageListPackageLabel.d.ts

@@ -0,0 +1,4 @@
+export declare const fixPackageLabel: (packageName: string, pluginList: Map<string, {
+    name: string;
+    label: string;
+}>) => string;

package/dist/utils/pageListPackageLabel.js

@@ -0,0 +1,12 @@
+const fixPackageLabel = (packageName, pluginList) => {
+  const PluginLabels = Array.from(pluginList.values());
+  for (const plugin of PluginLabels) {
+    if (plugin.name === packageName) {
+      return plugin.label;
+    }
+  }
+  return "Unknown";
+};
+export {
+  fixPackageLabel
+};

package/dist/utils/readJson.d.ts

@@ -0,0 +1 @@
+export declare function readJson<T>(path: string | URL): T;

package/dist/utils/readJson.js

@@ -0,0 +1,7 @@
+import fs from "node:fs";
+function readJson(path) {
+  return JSON.parse(fs.readFileSync(path, "utf-8"));
+}
+export {
+  readJson
+};

package/dist/utils/routeBuilder.d.ts

@@ -0,0 +1,18 @@
+import type { StudioCMSConfig } from '../schemas/index.js';
+export declare const makeDashboardRoute: (route: string, options: StudioCMSConfig) => string;
+export declare const injectAuthAPIRoutes: import("astro-integration-kit").HookUtility<"astro:config:setup", [opts: {
+    options: StudioCMSConfig;
+    routes: {
+        enabled: boolean;
+        pattern: string;
+        entrypoint: string;
+    }[];
+}], void>;
+export declare const injectAuthPageRoutes: import("astro-integration-kit").HookUtility<"astro:config:setup", [opts: {
+    options: StudioCMSConfig;
+    routes: {
+        enabled: boolean;
+        pattern: string;
+        entrypoint: string;
+    }[];
+}, prerenderRoutes: any], void>;

package/dist/utils/routeBuilder.js

@@ -0,0 +1,96 @@
+import { defineUtility } from "astro-integration-kit";
+import { makeAPIRoute, removeLeadingTrailingSlashes } from "../lib/index.js";
+import { integrationLogger } from "./integrationLogger.js";
+const apiRoute = makeAPIRoute("auth");
+const makeDashboardRoute = (route, options) => {
+  const {
+    dashboardConfig: { dashboardRouteOverride }
+  } = options;
+  const defaultDashboardRoute = dashboardRouteOverride ? removeLeadingTrailingSlashes(dashboardRouteOverride) : "dashboard";
+  return `${defaultDashboardRoute}/${route}`;
+};
+const injectAuthAPIRoutes = defineUtility("astro:config:setup")(
+  (params, opts) => {
+    const { injectRoute, logger } = params;
+    const {
+      options: {
+        verbose,
+        dashboardConfig: {
+          AuthConfig: { enabled: authEnabled },
+          developerConfig: { testingAndDemoMode }
+        }
+      },
+      routes
+    } = opts;
+    if (!authEnabled) {
+      integrationLogger(
+        { logger, logLevel: "info", verbose },
+        "Auth is Disabled by the User Configuration.  You will only be able to edit the database directly"
+      );
+      return;
+    }
+    integrationLogger(
+      { logger, logLevel: "info", verbose },
+      "Auth is Enabled, Setting Up API Routes..."
+    );
+    if (testingAndDemoMode) {
+      integrationLogger(
+        { logger, logLevel: "info", verbose },
+        "Testing and Demo Mode is Enabled, Authentication will not be required to access dashboard pages.  But you will only be able to edit the database directly"
+      );
+    }
+    for (const route of routes) {
+      const { enabled, pattern, entrypoint } = route;
+      if (!enabled) {
+        continue;
+      }
+      injectRoute({
+        pattern: apiRoute(pattern),
+        entrypoint,
+        prerender: false
+      });
+    }
+  }
+);
+const injectAuthPageRoutes = defineUtility("astro:config:setup")(
+  (params, opts, prerenderRoutes) => {
+    const { injectRoute, logger } = params;
+    const {
+      options: {
+        verbose,
+        dashboardConfig: {
+          AuthConfig: { enabled: authEnabled }
+        }
+      },
+      options,
+      routes
+    } = opts;
+    if (!authEnabled) {
+      integrationLogger(
+        { logger, logLevel: "info", verbose },
+        "Auth is Disabled by the User Configuration.  You will only be able to edit the database directly"
+      );
+      return;
+    }
+    integrationLogger(
+      { logger, logLevel: "info", verbose },
+      "Auth is Enabled, Setting Up Auth Page Routes..."
+    );
+    for (const route of routes) {
+      const { enabled, pattern, entrypoint } = route;
+      if (!enabled) {
+        continue;
+      }
+      injectRoute({
+        pattern: makeDashboardRoute(pattern, options),
+        entrypoint,
+        prerender: prerenderRoutes
+      });
+    }
+  }
+);
+export {
+  injectAuthAPIRoutes,
+  injectAuthPageRoutes,
+  makeDashboardRoute
+};

package/dist/utils/safeString.d.ts

@@ -0,0 +1 @@
+export declare function convertToSafeString(string: string): string;

package/dist/utils/safeString.js

@@ -0,0 +1,6 @@
+function convertToSafeString(string) {
+  return string.replace(/[^a-zA-Z0-9]/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+export {
+  convertToSafeString
+};

package/dist/utils/simpleResponse.d.ts

@@ -0,0 +1 @@
+export declare const simpleResponse: (statusCode: number, message: string) => Response;