studiocms 0.1.0-beta.10

package/dist/lib/auth/user.js

@@ -0,0 +1,133 @@
+import studioCMS_SDK from "studiocms:sdk";
+import { hashPassword } from "./password.js";
+import { deleteSessionTokenCookie, sessionCookieName, validateSessionToken } from "./session.js";
+function verifyUsernameInput(username) {
+  if (username.length < 3 || username.length > 32) {
+    return false;
+  }
+  if (!/^[a-z0-9_-]+$/.test(username)) {
+    return false;
+  }
+  return true;
+}
+async function createUserAvatar(email) {
+  const safeEmail = email.trim().toLowerCase();
+  const msgUint8 = new TextEncoder().encode(safeEmail);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", msgUint8);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `https://seccdn.libravatar.org/avatar/${hashHex}?s=400&d=retro`;
+}
+async function createLocalUser(name, username, email, password) {
+  const passwordHash = await hashPassword(password);
+  const avatar = await createUserAvatar(email);
+  const newUser = await studioCMS_SDK.AUTH.user.create({
+    id: crypto.randomUUID(),
+    name,
+    username,
+    email,
+    password: passwordHash,
+    createdAt: /* @__PURE__ */ new Date(),
+    avatar
+  });
+  return newUser;
+}
+async function createOAuthUser(userFields, oAuthFields) {
+  try {
+    const newUser = await studioCMS_SDK.AUTH.user.create(userFields);
+    await studioCMS_SDK.AUTH.oAuth.create({
+      userId: newUser.id,
+      provider: oAuthFields.provider,
+      providerUserId: oAuthFields.providerUserId
+    });
+    return newUser;
+  } catch (error) {
+    console.error(error);
+    return { error: "Error creating user" };
+  }
+}
+const LinkNewOAuthCookieName = "link-new-o-auth";
+async function updateUserPassword(userId, password) {
+  const passwordHash = await hashPassword(password);
+  await studioCMS_SDK.AUTH.user.update(userId, { password: passwordHash });
+}
+async function getUserPasswordHash(userId) {
+  const user = await studioCMS_SDK.GET.databaseEntry.users.byId(userId);
+  if (!user) {
+    throw new Error("User not found");
+  }
+  if (!user.password) {
+    throw new Error("User has no password");
+  }
+  return user.password;
+}
+async function getUserFromEmail(email) {
+  return await studioCMS_SDK.GET.databaseEntry.users.byEmail(email) ?? null;
+}
+async function getUserData(Astro) {
+  const { cookies } = Astro;
+  const sessionToken = cookies.get(sessionCookieName)?.value ?? null;
+  if (!sessionToken) {
+    return { isLoggedIn: false, user: null, permissionLevel: "unknown" };
+  }
+  const { session, user } = await validateSessionToken(sessionToken);
+  if (session === null) {
+    deleteSessionTokenCookie(Astro);
+    return { isLoggedIn: false, user: null, permissionLevel: "unknown" };
+  }
+  if (!user || user === null) {
+    return { isLoggedIn: false, user: null, permissionLevel: "unknown" };
+  }
+  const result = await studioCMS_SDK.AUTH.permission.currentStatus(user.id);
+  if (!result) {
+    return { isLoggedIn: true, user, permissionLevel: "unknown" };
+  }
+  let permissionLevel = "unknown";
+  switch (result.rank) {
+    case "owner":
+      permissionLevel = "owner";
+      break;
+    case "admin":
+      permissionLevel = "admin";
+      break;
+    case "editor":
+      permissionLevel = "editor";
+      break;
+    case "visitor":
+      permissionLevel = "visitor";
+      break;
+    default:
+      permissionLevel = "unknown";
+      break;
+  }
+  return {
+    isLoggedIn: true,
+    user,
+    permissionLevel
+  };
+}
+const availablePermissionRanks = ["owner", "admin", "editor", "visitor", "unknown"];
+const permissionRanksMap = {
+  owner: ["owner"],
+  admin: ["owner", "admin"],
+  editor: ["owner", "admin", "editor"],
+  visitor: ["owner", "admin", "editor", "visitor"],
+  unknown: ["owner", "admin", "editor", "visitor", "unknown"]
+};
+async function verifyUserPermissionLevel(userData, requiredPermission) {
+  const { permissionLevel } = userData;
+  return permissionRanksMap[requiredPermission].includes(permissionLevel);
+}
+export {
+  LinkNewOAuthCookieName,
+  createLocalUser,
+  createOAuthUser,
+  createUserAvatar,
+  getUserData,
+  getUserFromEmail,
+  getUserPasswordHash,
+  permissionRanksMap,
+  updateUserPassword,
+  verifyUserPermissionLevel,
+  verifyUsernameInput
+};

package/dist/lib/dashboardGrid.d.ts

@@ -0,0 +1,119 @@
+import type { HeroIconName } from '@studiocms/ui/components/Icon/iconType.js';
+import type { SanitizeOptions } from 'ultrahtml/transformers/sanitize';
+/**
+ * Represents the input for a grid item in the dashboard.
+ */
+export interface GridItemInput {
+    /**
+     * The name of the grid item.
+     */
+    name: string;
+    /**
+     * The span of the grid item, which can be 1, 2, or 3.
+     */
+    span: 1 | 2 | 3;
+    /**
+     * The variant of the grid item, which can be 'default' or 'filled'.
+     */
+    variant: 'default' | 'filled';
+    /**
+     * The required permission level to view the grid item.
+     * Optional. Can be 'owner', 'admin', 'editor', or 'visitor'.
+     */
+    requiresPermission?: 'owner' | 'admin' | 'editor' | 'visitor';
+    /**
+     * The header of the grid item.
+     * Optional.
+     */
+    header?: {
+        /**
+         * The title of the header.
+         */
+        title: string;
+        /**
+         * The icon of the header.
+         * Optional.
+         */
+        icon?: HeroIconName;
+    };
+    /**
+     * The body of the grid item.
+     * Optional.
+     */
+    body?: {
+        /**
+         * The HTML content of the body.
+         */
+        html: string;
+        /**
+         * The components within the body.
+         * Optional.
+         */
+        components?: Record<string, string>;
+        /**
+         * The options for sanitizing the HTML content.
+         * Optional.
+         */
+        sanitizeOpts?: SanitizeOptions;
+    };
+}
+/**
+ * Represents an item that can be used in a dashboard grid.
+ */
+export interface GridItemUsable {
+    /**
+     * The name of the grid item.
+     */
+    name: string;
+    /**
+     * The span of the grid item, which can be 1, 2, or 3.
+     */
+    span: 1 | 2 | 3;
+    /**
+     * The variant of the grid item, which can be 'default' or 'filled'.
+     */
+    variant: 'default' | 'filled';
+    /**
+     * Optional. The permission required to use the grid item.
+     * Can be 'owner', 'admin', 'editor', or 'visitor'.
+     */
+    requiresPermission?: 'owner' | 'admin' | 'editor' | 'visitor';
+    /**
+     * Optional. The header of the grid item.
+     */
+    header?: {
+        /**
+         * The title of the header.
+         */
+        title: string;
+        /**
+         * Optional. The icon of the header.
+         */
+        icon?: HeroIconName;
+    };
+    /**
+     * Optional. The body of the grid item.
+     */
+    body?: {
+        /**
+         * The HTML content of the body.
+         */
+        html: string;
+        /**
+         * Optional. The components of the body.
+         *
+         */
+        components?: Record<string, any>;
+        /**
+         * Optional. The options for sanitizing the HTML content.
+         */
+        sanitizeOpts?: SanitizeOptions;
+    };
+}
+/**
+ * Represents an item in the dashboard grid.
+ * Extends the properties of `GridItemUsable` and adds an `enabled` flag.
+ */
+export interface GridItem extends GridItemUsable {
+    enabled: boolean;
+}

package/dist/lib/dynamic-sitemap/index.d.ts

@@ -0,0 +1,42 @@
+import type { AstroIntegration } from 'astro';
+/**
+ * Options for configuring the dynamic sitemap.
+ */
+interface DynamicSitemapOptions {
+    /**
+     * An array of sitemap configurations.
+     */
+    sitemaps: {
+        /**
+         * The name of the plugin that generates the sitemap.
+         */
+        pluginName: string;
+        /**
+         * The endpoint path or URL where the sitemap XML can be accessed.
+         */
+        sitemapXMLEndpointPath: string | URL;
+    }[];
+}
+/**
+ * Generates a dynamic sitemap integration for Astro.
+ *
+ * @param {DynamicSitemapOptions} options - Configuration options for the dynamic sitemap.
+ * @returns {AstroIntegration} The Astro integration object.
+ *
+ * The integration adds virtual imports for sitemaps and injects routes for the sitemap index and individual sitemaps.
+ *
+ * The `options` parameter should include:
+ * - `sitemaps`: An array of objects, each containing:
+ *   - `pluginName`: The name of the plugin.
+ *   - `sitemapXMLEndpointPath`: The entry point path for the sitemap XML.
+ *
+ * The function performs the following steps:
+ * 1. Creates a resolver using the current module URL.
+ * 2. Adds virtual imports for the sitemaps.
+ * 3. Injects a route for the sitemap index.
+ * 4. Iterates over the provided sitemaps and injects routes for each sitemap.
+ *
+ * If multiple sitemaps have the same pattern, a unique pattern is generated by appending an index.
+ */
+export declare function dynamicSitemap(options: DynamicSitemapOptions): AstroIntegration;
+export {};

package/dist/lib/dynamic-sitemap/index.js

@@ -0,0 +1,45 @@
+import { addVirtualImports, createResolver } from "astro-integration-kit";
+import { convertToSafeString } from "../../utils/safeString.js";
+function safeString(str) {
+  return convertToSafeString(str).replace(/^_+/, "").replace(/_+$/, "").replace("studiocms_", "");
+}
+function dynamicSitemap(options) {
+  const { resolve } = createResolver(import.meta.url);
+  return {
+    name: "studiocms/dynamic-sitemap",
+    hooks: {
+      "astro:config:setup": (params) => {
+        const { injectRoute } = params;
+        const { sitemaps } = options;
+        addVirtualImports(params, {
+          name: "studiocms/dynamic-sitemap",
+          imports: {
+            "virtual:studiocms/sitemaps": `
+                            export const sitemaps = ${JSON.stringify([...sitemaps.map(({ pluginName }) => `./sitemap-${safeString(pluginName)}.xml`)])};
+                        `
+          }
+        });
+        injectRoute({
+          entrypoint: resolve("./sitemap-index.xml.js"),
+          pattern: "/sitemap-index.xml",
+          prerender: false
+        });
+        const existingSitemaps = [];
+        for (const { pluginName, sitemapXMLEndpointPath: entrypoint } of sitemaps) {
+          let pattern = `/sitemap-${safeString(pluginName)}.xml`;
+          if (existingSitemaps.includes(pattern)) {
+            pattern = `/sitemap-${safeString(pluginName)}-${existingSitemaps.length}.xml`;
+          }
+          injectRoute({
+            entrypoint,
+            pattern,
+            prerender: false
+          });
+        }
+      }
+    }
+  };
+}
+export {
+  dynamicSitemap
+};

package/dist/lib/dynamic-sitemap/sitemap-index.xml.d.ts

@@ -0,0 +1,8 @@
+import type { APIRoute } from 'astro';
+/**
+ * Handles the GET request for generating a dynamic sitemap index.
+ *
+ * @param context - The API context containing the request information.
+ * @returns A Response object containing the generated sitemap index in XML format.
+ */
+export declare const GET: APIRoute;

package/dist/lib/dynamic-sitemap/sitemap-index.xml.js

@@ -0,0 +1,20 @@
+import { sitemaps } from "virtual:studiocms/sitemaps";
+const template = (entries) => `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+    ${entries.map((entry) => `<sitemap><loc>${entry.location}</loc></sitemap>`).join("")}
+</sitemapindex>`;
+const GET = async (context) => {
+  const CurrentUrl = context.url;
+  const sitemap = template(
+    sitemaps.map((sitemap2) => ({ location: new URL(sitemap2, CurrentUrl).toString() }))
+  );
+  return new Response(sitemap, {
+    status: 200,
+    headers: {
+      "Content-Type": "application/xml"
+    }
+  });
+};
+export {
+  GET
+};

package/dist/lib/dynamic-sitemap/sitemap-index.xml.ts

@@ -0,0 +1,45 @@
+import { sitemaps } from 'virtual:studiocms/sitemaps';
+import type { APIContext, APIRoute } from 'astro';
+
+/**
+ * Generates an XML sitemap index from an array of entries.
+ *
+ * @param entries - An array of objects containing the location URLs for the sitemap.
+ * @returns A string representing the XML sitemap index.
+ *
+ * @example
+ * const entries = [{ location: 'https://example.com/sitemap1.xml' }, { location: 'https://example.com/sitemap2.xml' }];
+ * const sitemapIndex = template(entries);
+ * console.log(sitemapIndex);
+ * // Output:
+ * // <?xml version="1.0" encoding="UTF-8"?>
+ * // <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+ * //     <sitemap><loc>https://example.com/sitemap1.xml</loc></sitemap>
+ * //     <sitemap><loc>https://example.com/sitemap2.xml</loc></sitemap>
+ * // </sitemapindex>
+ */
+const template = (entries: { location: string }[]) => `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+    ${entries.map((entry) => `<sitemap><loc>${entry.location}</loc></sitemap>`).join('')}
+</sitemapindex>`;
+
+/**
+ * Handles the GET request for generating a dynamic sitemap index.
+ *
+ * @param context - The API context containing the request information.
+ * @returns A Response object containing the generated sitemap index in XML format.
+ */
+export const GET: APIRoute = async (context: APIContext) => {
+	const CurrentUrl = context.url;
+
+	const sitemap = template(
+		sitemaps.map((sitemap) => ({ location: new URL(sitemap, CurrentUrl).toString() }))
+	);
+
+	return new Response(sitemap, {
+		status: 200,
+		headers: {
+			'Content-Type': 'application/xml',
+		},
+	});
+};

package/dist/lib/head.d.ts

@@ -0,0 +1,9 @@
+import { type HeadConfig, HeadConfigSchema, type HeadUserConfig } from '../schemas/config/defaultFrontend.js';
+export { HeadConfigSchema };
+export type { HeadConfig, HeadUserConfig };
+/** Create a fully parsed, merged, and sorted head entry array from multiple sources. */
+export declare function createHead(defaults: HeadUserConfig, ...heads: HeadConfig[]): {
+    content: string;
+    tag: "base" | "link" | "meta" | "noscript" | "script" | "style" | "template" | "title";
+    attrs: Record<string, string | boolean | undefined>;
+}[];

package/dist/lib/head.js

@@ -0,0 +1,65 @@
+import {
+  HeadConfigSchema
+} from "../schemas/config/defaultFrontend.js";
+const HeadSchema = HeadConfigSchema();
+function createHead(defaults, ...heads) {
+  let head = HeadSchema.parse(defaults);
+  for (const next of heads) {
+    head = mergeHead(head, next);
+  }
+  return sortHead(head);
+}
+function hasTag(head, entry) {
+  switch (entry.tag) {
+    case "title":
+      return head.some(({ tag }) => tag === "title");
+    case "meta":
+      return hasOneOf(head, entry, ["name", "property", "http-equiv"]);
+    default:
+      return false;
+  }
+}
+function hasOneOf(head, entry, keys) {
+  const attr = getAttr(keys, entry);
+  if (!attr) return false;
+  const [key, val] = attr;
+  return head.some(({ tag, attrs }) => tag === entry.tag && attrs[key] === val);
+}
+function getAttr(keys, entry) {
+  let attr;
+  for (const key of keys) {
+    const val = entry.attrs[key];
+    if (val) {
+      attr = [key, val];
+      break;
+    }
+  }
+  return attr;
+}
+function mergeHead(oldHead, newHead) {
+  return [...oldHead.filter((tag) => !hasTag(newHead, tag)), ...newHead];
+}
+function sortHead(head) {
+  return head.sort((a, b) => {
+    const aImportance = getImportance(a);
+    const bImportance = getImportance(b);
+    return aImportance > bImportance ? -1 : bImportance > aImportance ? 1 : 0;
+  });
+}
+function getImportance(entry) {
+  if (entry.tag === "meta" && ("charset" in entry.attrs || "http-equiv" in entry.attrs || entry.attrs.name === "viewport")) {
+    return 100;
+  }
+  if (entry.tag === "title") return 90;
+  if (entry.tag !== "meta") {
+    if (entry.tag === "link" && "rel" in entry.attrs && entry.attrs.rel === "shortcut icon") {
+      return 70;
+    }
+    return 80;
+  }
+  return 0;
+}
+export {
+  HeadConfigSchema,
+  createHead
+};

package/dist/lib/headDefaults.d.ts

@@ -0,0 +1,18 @@
+import type { AstroGlobalPartial } from 'astro';
+/**
+ * Default Head Tags for use with createHead() helper
+ *
+ * @param title
+ * @param description
+ * @param lang
+ * @param Astro
+ * @param favicon
+ * @param ogImage
+ * @param canonical
+ * @returns
+ */
+export declare const headDefaults: (title: string, description: string, lang: string, Astro: AstroGlobalPartial, favicon: string, ogImage: string | undefined, canonical: URL | undefined) => {
+    tag: "base" | "link" | "meta" | "noscript" | "script" | "style" | "template" | "title";
+    content?: string | undefined;
+    attrs?: Record<string, string | boolean | undefined> | undefined;
+}[];

package/dist/lib/headDefaults.js

@@ -0,0 +1,75 @@
+import { extname } from "node:path";
+import version from "studiocms:version";
+import { lookup } from "mrmime";
+import { StudioCMSCoreError } from "../errors.js";
+const faviconTypes = [".ico", ".gif", ".jpeg", ".jpg", ".png", ".svg"];
+function isFaviconExt(ext) {
+  if (faviconTypes.includes(ext)) {
+    return true;
+  }
+  return false;
+}
+const makeFavicon = (favicon) => {
+  const ext = extname(favicon).toLocaleLowerCase();
+  if (isFaviconExt(ext)) {
+    const faviconHref = favicon;
+    const faviconType = lookup(ext);
+    return { href: faviconHref, type: faviconType };
+  }
+  throw new StudioCMSCoreError(
+    `Unsupported favicon extension: ${ext}`,
+    `The favicon must be one of the following types: ${faviconTypes.join(", ")}`
+  );
+};
+const headDefaults = (title, description, lang, Astro, favicon, ogImage, canonical) => {
+  const headDefaults2 = [
+    { tag: "meta", attrs: { charset: "utf-8" } },
+    {
+      tag: "meta",
+      attrs: { name: "viewport", content: "width=device-width, initial-scale=1" }
+    },
+    { tag: "title", content: `${title}` },
+    { tag: "meta", attrs: { name: "title", content: title } },
+    { tag: "meta", attrs: { name: "description", content: description } },
+    { tag: "link", attrs: { rel: "canonical", href: canonical?.href } },
+    { tag: "meta", attrs: { name: "generator", content: Astro.generator } },
+    {
+      tag: "meta",
+      attrs: { name: "generator", content: `StudioCMS v${version}` }
+    },
+    // Favicon
+    {
+      tag: "link",
+      attrs: {
+        rel: "shortcut icon",
+        href: makeFavicon(favicon).href,
+        type: makeFavicon(favicon).type
+      }
+    },
+    // OpenGraph Tags
+    { tag: "meta", attrs: { property: "og:title", content: title } },
+    { tag: "meta", attrs: { property: "og:type", content: "website" } },
+    { tag: "meta", attrs: { property: "og:url", content: canonical?.href } },
+    { tag: "meta", attrs: { property: "og:locale", content: lang } },
+    { tag: "meta", attrs: { property: "og:description", content: description } },
+    { tag: "meta", attrs: { property: "og:site_name", content: title } },
+    // Twitter Tags
+    {
+      tag: "meta",
+      attrs: { name: "twitter:card", content: "summary_large_image" }
+    },
+    { tag: "meta", attrs: { name: "twitter:url", content: canonical?.href } },
+    { tag: "meta", attrs: { name: "twitter:title", content: title } },
+    { tag: "meta", attrs: { name: "twitter:description", content: description } }
+  ];
+  if (ogImage) {
+    headDefaults2.push(
+      { tag: "meta", attrs: { property: "og:image", content: ogImage } },
+      { tag: "meta", attrs: { name: "twitter:image", content: ogImage } }
+    );
+  }
+  return headDefaults2;
+};
+export {
+  headDefaults
+};