studiocms 0.1.0-beta.10

package/dist/utils/changelogLoader.js

@@ -0,0 +1,104 @@
+import fs from "node:fs";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toString as ToString } from "mdast-util-to-string";
+import { visit } from "unist-util-visit";
+const semverCategories = ["major", "minor", "patch"];
+function loadChangelog(path) {
+  let markdown = fs.readFileSync(path, "utf8");
+  markdown = markdown.replace(
+    /(?<=Thank[^.!]*? )@([a-z0-9-]+)(?=[\s,.!])/gi,
+    "[@$1](https://github.com/$1)"
+  );
+  const ast = fromMarkdown(markdown);
+  const changelog = {
+    packageName: "",
+    versions: []
+  };
+  let state = "packageName";
+  let version;
+  let semverCategory;
+  function handleNode(node) {
+    if (node.type === "heading") {
+      if (node.depth === 1) {
+        if (state !== "packageName") throw new Error("Unexpected h1");
+        changelog.packageName = ToString(node);
+        state = "version";
+        return;
+      }
+      if (node.depth === 2) {
+        if (state === "packageName") throw new Error("Unexpected h2");
+        version = {
+          version: ToString(node),
+          changes: {
+            major: { type: "list", children: [] },
+            minor: { type: "list", children: [] },
+            patch: { type: "list", children: [] }
+          },
+          includes: /* @__PURE__ */ new Set()
+        };
+        changelog.versions.push(version);
+        state = "semverCategory";
+        return;
+      }
+      if (node.depth === 3) {
+        if (state === "packageName" || state === "version") throw new Error("Unexpected h3");
+        semverCategory = (ToString(node).split(" ")[0] || "").toLowerCase();
+        if (!semverCategories.includes(semverCategory))
+          throw new Error(`Unexpected semver category: ${semverCategory}`);
+        state = "changes";
+        return;
+      }
+    }
+    if (node.type === "list") {
+      if (state !== "changes" || !version || !semverCategory) throw new Error("Unexpected list");
+      for (let listItemIdx = 0; listItemIdx < node.children.length; listItemIdx++) {
+        const listItem = node.children[listItemIdx];
+        if (!listItem) continue;
+        const lastChild = listItem.children[listItem.children.length - 1];
+        if (lastChild?.type === "list") {
+          const packageRefs = [];
+          lastChild.children.forEach((subListItem) => {
+            const text = ToString(subListItem);
+            if (parsePackageReference(text)) packageRefs.push(text);
+          });
+          if (packageRefs.length === lastChild.children.length) {
+            for (const packageRef of packageRefs) {
+              version.includes.add(packageRef);
+            }
+            listItem.children.pop();
+          }
+        }
+        const firstPara = listItem.children[0]?.type === "paragraph" ? listItem.children[0] : void 0;
+        if (firstPara) {
+          visit(firstPara, "text", (textNode) => {
+            textNode.value = textNode.value.replace(/(^[0-9a-f]{7,}: | \[[0-9a-f]{7,}\]$)/, "");
+          });
+          const firstParaText = ToString(firstPara);
+          if (firstParaText === "Updated dependencies") continue;
+          const packageRef = parsePackageReference(firstParaText);
+          if (packageRef) {
+            version.includes.add(firstParaText);
+            continue;
+          }
+          version.changes[semverCategory].children.push(listItem);
+        }
+      }
+      return;
+    }
+    throw new Error(`Unexpected node: ${JSON.stringify(node)}`);
+  }
+  ast.children.forEach((node) => {
+    handleNode(node);
+  });
+  return changelog;
+}
+function parsePackageReference(str) {
+  const matches = str.match(/^([@/a-z0-9-]+)@([0-9.]+)$/);
+  if (!matches) return;
+  const [, packageName, version] = matches;
+  return { packageName, version };
+}
+export {
+  loadChangelog,
+  semverCategories
+};

package/dist/utils/checkENV.d.ts

@@ -0,0 +1,27 @@
+import type { AstroIntegrationLogger } from 'astro';
+import type { StudioCMSConfig } from '../schemas/index.js';
+export declare const CheckENVStrings: {
+    CheckStart: string;
+    CheckComplete: string;
+    GithubMessages: {
+        CheckMessage: string;
+        ErrorMessage: string;
+    };
+    DiscordMessages: {
+        CheckMessage: string;
+        ErrorMessage: string;
+    };
+    GoogleMessages: {
+        CheckMessage: string;
+        ErrorMessage: string;
+    };
+    Auth0Messages: {
+        CheckMessage: string;
+        ErrorMessage: string;
+    };
+    EncryptionMessages: {
+        CheckMessage: string;
+        ErrorMessage: string;
+    };
+};
+export declare const checkEnvKeys: (logger: AstroIntegrationLogger, options: StudioCMSConfig) => Promise<void>;

package/dist/utils/checkENV.js

@@ -0,0 +1,115 @@
+import { loadEnv } from "vite";
+import { integrationLogger } from "./integrationLogger.js";
+const env = loadEnv("all", process.cwd(), "CMS");
+const CheckENVStrings = {
+  CheckStart: "Checking Environment Variables...",
+  CheckComplete: "Environment Variables Check Complete.",
+  GithubMessages: {
+    CheckMessage: "Github Auth Enabled, Checking Github Environment Variables...",
+    ErrorMessage: "The Following Github Keys are Missing and are Required for the Github Authentication to work:"
+  },
+  DiscordMessages: {
+    CheckMessage: "Discord Auth Enabled, Checking Discord Environment Variables...",
+    ErrorMessage: "The Following Discord Keys are Missing and are Required for the Discord Authentication to work:"
+  },
+  GoogleMessages: {
+    CheckMessage: "Google Auth Enabled, Checking Google Environment Variables...",
+    ErrorMessage: "The Following Google Keys are Missing and are Required for the Google Authentication to work:"
+  },
+  Auth0Messages: {
+    CheckMessage: "Auth0 Auth Enabled, Checking Auth0 Environment Variables...",
+    ErrorMessage: "The Following Auth0 Keys are Missing and are Required for the Auth0 Authentication to work:"
+  },
+  EncryptionMessages: {
+    CheckMessage: "Checking Encryption Key...",
+    ErrorMessage: "The CMS_ENCRYPTION_KEY is Missing and is Required for StudioCMS to work:"
+  }
+};
+const keyList = {
+  EncryptionKey: {
+    Keys: ["CMS_ENCRYPTION_KEY"],
+    messages: CheckENVStrings.EncryptionMessages
+  },
+  Github: {
+    Keys: ["CMS_GITHUB_CLIENT_ID", "CMS_GITHUB_CLIENT_SECRET"],
+    optionalKeys: ["CMS_GITHUB_REDIRECT_URI"],
+    messages: CheckENVStrings.GithubMessages
+  },
+  Discord: {
+    Keys: ["CMS_DISCORD_CLIENT_ID", "CMS_DISCORD_CLIENT_SECRET", "CMS_DISCORD_REDIRECT_URI"],
+    messages: CheckENVStrings.DiscordMessages
+  },
+  Google: {
+    Keys: ["CMS_GOOGLE_CLIENT_ID", "CMS_GOOGLE_CLIENT_SECRET", "CMS_GOOGLE_REDIRECT_URI"],
+    messages: CheckENVStrings.GoogleMessages
+  },
+  Auth0: {
+    Keys: [
+      "CMS_AUTH0_CLIENT_ID",
+      "CMS_AUTH0_CLIENT_SECRET",
+      "CMS_AUTH0_DOMAIN",
+      "CMS_AUTH0_REDIRECT_URI"
+    ],
+    messages: CheckENVStrings.Auth0Messages
+  }
+};
+function matchAvailableProviders(providers) {
+  const { github, discord, google, auth0 } = providers;
+  const enabledProviders = ["EncryptionKey"];
+  if (github) {
+    enabledProviders.push("Github");
+  }
+  if (discord) {
+    enabledProviders.push("Discord");
+  }
+  if (google) {
+    enabledProviders.push("Google");
+  }
+  if (auth0) {
+    enabledProviders.push("Auth0");
+  }
+  return enabledProviders;
+}
+const checkEnvKeys = async (logger, options) => {
+  const {
+    verbose,
+    dashboardConfig: {
+      AuthConfig: { providers }
+    }
+  } = options;
+  const infoLogger = (message) => {
+    integrationLogger({ logger, logLevel: "info", verbose }, message);
+  };
+  const warnLogger = (message) => {
+    integrationLogger({ logger, logLevel: "warn", verbose: true }, message);
+  };
+  infoLogger(CheckENVStrings.CheckStart);
+  const enabledProviders = matchAvailableProviders(providers);
+  for (const provider of enabledProviders) {
+    const ProviderItem = keyList[provider];
+    if (!ProviderItem) {
+      continue;
+    }
+    const { messages, Keys, optionalKeys } = ProviderItem;
+    infoLogger(messages.CheckMessage);
+    const missingProviderKeys = [];
+    for (const key of Keys) {
+      if (!env[key]) {
+        missingProviderKeys.push(key);
+      }
+    }
+    for (const key of optionalKeys || []) {
+      if (!env[key]) {
+        warnLogger(`The following optional key is missing and may or may not be required: ${key}`);
+      }
+    }
+    if (missingProviderKeys.length > 0) {
+      warnLogger(`${messages.ErrorMessage} ${missingProviderKeys.join(", ")}`);
+    }
+  }
+  infoLogger(CheckENVStrings.CheckComplete);
+};
+export {
+  CheckENVStrings,
+  checkEnvKeys
+};

package/dist/utils/configManager.d.ts

@@ -0,0 +1,22 @@
+import type { StudioCMSOptions } from '../schemas/index.js';
+export declare function exists(path: string | undefined): boolean;
+/**
+ * Returns a URL to the optional StudioCMS config file in the Astro project root.
+ */
+export declare function getStudioConfigFileUrl(projectRootUrl: string): string | undefined;
+/**
+ * Watches the StudioCMS configuration file for changes and adds it to the watch list.
+ * This utility is defined for the 'astro:config:setup' event.
+ *
+ * @param params - The parameters provided by the Astro configuration setup event.
+ * @param params.addWatchFile - Function to add a file to the watch list.
+ * @param params.config - The current Astro configuration object.
+ * @returns void
+ */
+export declare const watchStudioCMSConfig: import("astro-integration-kit").HookUtility<"astro:config:setup", [], void>;
+/**
+ * Attempts to import an StudioCMS  config file in the Astro project root and returns its default export.
+ *
+ * If no config file is found, an empty object is returned.
+ */
+export declare function loadStudioCMSConfigFile(projectRootUrl: URL): Promise<StudioCMSOptions>;

package/dist/utils/configManager.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import { defineUtility } from "astro-integration-kit";
+import { StudioCMSCoreError } from "../errors.js";
+const configPaths = Object.freeze([
+  "studiocms.config.js",
+  "studiocms.config.mjs",
+  "studiocms.config.cjs",
+  "studiocms.config.ts",
+  "studiocms.config.mts",
+  "studiocms.config.cts"
+]);
+function findConfig(projectRootUrl) {
+  for (const path of configPaths) {
+    const configUrl = `${projectRootUrl}${path}`;
+    if (exists(configUrl)) {
+      return configUrl;
+    }
+  }
+  return void 0;
+}
+function exists(path) {
+  if (!path) return false;
+  try {
+    fs.statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getStudioConfigFileUrl(projectRootUrl) {
+  const configPath = findConfig(projectRootUrl);
+  if (configPath) {
+    return configPath;
+  }
+  return void 0;
+}
+const watchStudioCMSConfig = defineUtility("astro:config:setup")(
+  ({
+    addWatchFile,
+    config: {
+      root: { pathname }
+    }
+  }) => {
+    const configFileUrl = getStudioConfigFileUrl(pathname);
+    if (configFileUrl) {
+      addWatchFile(configFileUrl);
+    }
+    return;
+  }
+);
+async function loadStudioCMSConfigFile(projectRootUrl) {
+  const pathsToTry = [
+    new URL(`./studiocms.config.js?t=${Date.now()}`, projectRootUrl).href,
+    new URL(`./studiocms.config.cjs?t=${Date.now()}`, projectRootUrl).href,
+    new URL(`./studiocms.config.mjs?t=${Date.now()}`, projectRootUrl).href,
+    new URL(`./studiocms.config.ts?t=${Date.now()}`, projectRootUrl).href,
+    new URL(`./studiocms.config.cts?t=${Date.now()}`, projectRootUrl).href,
+    new URL(`./studiocms.config.mts?t=${Date.now()}`, projectRootUrl).href
+  ];
+  function coerceError(error) {
+    if (typeof error === "object" && error !== null && "message" in error) {
+      return error;
+    }
+    return { message: error };
+  }
+  for (const path of pathsToTry) {
+    try {
+      const module = await import(
+        /* @vite-ignore */
+        path
+      );
+      if (!module.default) {
+        throw new StudioCMSCoreError(
+          "Missing or invalid default export. Please export your StudioCMS config object as the default export."
+        );
+      }
+      return module.default;
+    } catch (error) {
+      const { message, code } = coerceError(error);
+      if (code === "ERR_MODULE_NOT_FOUND" || code === "ERR_LOAD_URL") {
+        const msgCheck = message.replace(/(imported )?from .*$/, "");
+        if (msgCheck.includes("studiocms.config.js") || msgCheck.includes("studiocms.config.mjs") || msgCheck.includes("studiocms.config.cjs") || msgCheck.includes("studiocms.config.ts") || msgCheck.includes("studiocms.config.mts") || msgCheck.includes("studiocms.config.cts"))
+          continue;
+      }
+      throw new StudioCMSCoreError(
+        `Your project includes an StudioCMS config file (${path}) that could not be loaded due to ${code ? `the error ${code}` : "the following error"}: ${message}`.replace(/\s+/g, " "),
+        error instanceof Error ? error.stack : ""
+      );
+    }
+  }
+  return void 0;
+}
+export {
+  exists,
+  getStudioConfigFileUrl,
+  loadStudioCMSConfigFile,
+  watchStudioCMSConfig
+};

package/dist/utils/configResolver.d.ts

@@ -0,0 +1,283 @@
+import { type StudioCMSConfig, type StudioCMSOptions } from '../schemas/index.js';
+export declare function parseConfig(opts: StudioCMSOptions): StudioCMSConfig;
+/**
+ * Resolves the StudioCMS Options
+ *
+ * @param {import("astro").HookParameters<"astro:config:setup">} params
+ * @param {StudioCMSOptions} options
+ *
+ * @returns {StudioCMSConfig} The resolved StudioCMS Options
+ */
+export declare const configResolver: import("astro-integration-kit").HookUtility<"astro:config:setup", [options: {
+    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], Promise<{
+    dbStartPage: boolean;
+    rendererConfig: {
+        studiocms: {
+            callouts: {
+                enabled: boolean;
+                theme: "github" | "obsidian" | "vitepress";
+            };
+            autoLinkHeadings: boolean;
+            discordSubtext: boolean;
+            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;
+        };
+        renderer: "studiocms" | import("../config.js").CustomRenderer | "astro" | "markdoc" | "mdx";
+        markdocConfig: {
+            renderType: "html" | import("../schemas/config/markdoc.js").MarkdocRenderer | "react-static";
+            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;
+        };
+        mdxConfig: {
+            remarkPlugins: import("unified").PluggableList;
+            rehypePlugins: import("unified").PluggableList;
+            recmaPlugins: import("unified").PluggableList;
+            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;
+            };
+        };
+    };
+    imageService: {
+        cdnPlugin?: "cloudinary-js" | undefined;
+    };
+    defaultFrontEndConfig: boolean | {
+        htmlDefaultLanguage: string;
+        htmlDefaultHead: {
+            content: string;
+            tag: "base" | "link" | "meta" | "noscript" | "script" | "style" | "template" | "title";
+            attrs: Record<string, string | boolean | undefined>;
+        }[];
+        favicon: string;
+        injectQuickActionsMenu: boolean;
+    };
+    dashboardConfig: {
+        dashboardEnabled: boolean;
+        inject404Route: boolean;
+        faviconURL: string;
+        AuthConfig: {
+            providers: {
+                github: boolean;
+                discord: boolean;
+                google: boolean;
+                auth0: boolean;
+                usernameAndPassword: boolean;
+                usernameAndPasswordConfig: {
+                    allowUserRegistration: boolean;
+                };
+            };
+            enabled: boolean;
+        };
+        developerConfig: {
+            testingAndDemoMode: boolean;
+        };
+        versionCheck: boolean;
+        dashboardRouteOverride?: string | undefined;
+    };
+    includedIntegrations: {
+        robotsTXT: boolean | import("../lib/robots/types.js").RobotsConfig;
+    };
+    dateLocale: string;
+    dateTimeFormat: Intl.DateTimeFormatOptions;
+    overrides: {
+        CustomImageOverride?: string | undefined;
+        FormattedDateOverride?: string | undefined;
+    };
+    verbose: boolean;
+    sdk: {
+        cacheConfig: {
+            enabled: boolean;
+            lifetime: number;
+        };
+    };
+    plugins?: import("../plugins.js").StudioCMSPlugin[] | undefined;
+    componentRegistry?: Record<string, string> | undefined;
+}>>;