studiocms 0.2.0 → 0.4.0

package/dist/plugins/analytics/index.js

@@ -1,9 +1,9 @@
 import { runEffect } from "@withstudiocms/effect";
 import createPathResolver from "@withstudiocms/internal_helpers/pathResolver";
 import { addVirtualImports } from "astro-integration-kit";
-import { KyselyTableManager } from "#db/plugins";
-import { buildTranslations, loadJsTranslations } from "#plugins";
-import { definePlugin } from "#schemas";
+import { KyselyTableManager } from "../../db/plugins";
+import { buildTranslations, loadJsTranslations } from "../../plugins";
+import { definePlugin } from "../../schemas";
 import { WEB_VITALS_ENDPOINT_PATH } from "./consts.js";
 import { getAnalyticsDbClient } from "./db-client.js";
 import { StudioCMSMetricTableDefinition } from "./table.js";
@@ -40,7 +40,6 @@ const webVitalsIntegration = () => {
 const studioCMSAnalyticsPlugin = (opts) => definePlugin({
   name: "Web Vitals (built-in)",
   identifier: pkgName,
-  studiocmsMinimumVersion: opts.version,
   hooks: {
     "studiocms:astro-config": async ({ addIntegrations }) => {
       const dbClient = await runEffect(getAnalyticsDbClient(opts.driverDialect));
@@ -51,7 +50,7 @@ const studioCMSAnalyticsPlugin = (opts) => definePlugin({
       await tableManager.initialize();
       addIntegrations(webVitalsIntegration());
     },
-    "studiocms:dashboard": ({ setDashboard }) => {
+    "studiocms:dashboard": async ({ setDashboard }) => {
       setDashboard({
         translations,
         dashboardGridItems: [

package/dist/plugins/analytics/schemas.d.ts

@@ -1,65 +1,57 @@
-import { z } from 'astro/zod';
-/** Shape of the data submitted from clients to the collection API. */
-declare const ClientMetricSchema: z.ZodObject<{
-    pathname: z.ZodString;
-    route: z.ZodString;
-    name: z.ZodEnum<["CLS", "INP", "LCP", "FCP", "TTFB"]>;
-    id: z.ZodEffects<z.ZodString, string, string>;
-    value: z.ZodNumber;
-    rating: z.ZodEnum<["good", "needs-improvement", "poor"]>;
-}, "strip", z.ZodTypeAny, {
-    value: number;
-    name: "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
-    route: string;
-    id: string;
-    pathname: string;
-    rating: "good" | "needs-improvement" | "poor";
-}, {
-    value: number;
-    name: "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
-    route: string;
-    id: string;
-    pathname: string;
-    rating: "good" | "needs-improvement" | "poor";
+import * as Schema from 'effect/Schema';
+/**
+ * Schema for validating and transforming client-submitted web performance metric ratings. The input must be one of the following strings: 'good', 'needs-improvement', or 'poor'. This schema ensures that only valid rating values are accepted and provides a clear definition of the expected values for the rating field in client-submitted data.
+ */
+export declare const RatingSchema: Schema.Literal<["good", "needs-improvement", "poor"]>;
+/**
+ * Schema for validating and transforming client-submitted web performance metric types. The input must be one of the following strings: 'CLS', 'INP', 'LCP', 'FCP', or 'TTFB'. This schema ensures that only valid metric types are accepted and provides a clear definition of the expected values for the metric type field in client-submitted data.
+ */
+export declare const MetricTypeSchema: Schema.Literal<["CLS", "INP", "LCP", "FCP", "TTFB"]>;
+/**
+ * Schema for validating and transforming client-submitted web performance metric IDs. The input must be a string matching the pattern `v5-<13 digits>-<13 digits>`. The schema transforms the ID by removing the last 5 digits of the first numeric segment to reduce data resolution while maintaining uniqueness. This transformation helps to balance the need for unique identifiers with privacy considerations by reducing the granularity of the data.
+ */
+export declare const MetricIdSchema: Schema.transformOrFail<typeof Schema.String, typeof Schema.String, never>;
+/**
+ * Schema representing a client-submitted web performance metric, including its type, value, and associated metadata.
+ */
+export declare const ClientMetricSchema: Schema.Struct<{
+    pathname: typeof Schema.String;
+    route: typeof Schema.String;
+    name: Schema.Literal<["CLS", "INP", "LCP", "FCP", "TTFB"]>;
+    id: Schema.transformOrFail<typeof Schema.String, typeof Schema.String, never>;
+    value: Schema.refine<number, typeof Schema.Number>;
+    rating: Schema.Literal<["good", "needs-improvement", "poor"]>;
 }>;
-/** Transformed client data with added timestamp. */
-export declare const ServerMetricSchema: z.ZodEffects<z.ZodObject<{
-    pathname: z.ZodString;
-    route: z.ZodString;
-    name: z.ZodEnum<["CLS", "INP", "LCP", "FCP", "TTFB"]>;
-    id: z.ZodEffects<z.ZodString, string, string>;
-    value: z.ZodNumber;
-    rating: z.ZodEnum<["good", "needs-improvement", "poor"]>;
-}, "strip", z.ZodTypeAny, {
-    value: number;
-    name: "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
-    route: string;
-    id: string;
-    pathname: string;
-    rating: "good" | "needs-improvement" | "poor";
-}, {
-    value: number;
-    name: "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
-    route: string;
-    id: string;
-    pathname: string;
-    rating: "good" | "needs-improvement" | "poor";
-}>, {
-    timestamp: Date;
-    value: number;
-    name: "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
-    route: string;
-    id: string;
-    pathname: string;
-    rating: "good" | "needs-improvement" | "poor";
-}, {
-    value: number;
-    name: "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
-    route: string;
-    id: string;
-    pathname: string;
-    rating: "good" | "needs-improvement" | "poor";
+/**
+ * Schema for server-stored metrics, which includes all fields from the client-submitted metric along with a timestamp. The timestamp is generated on the server to indicate when the metric was processed, and the ID is transformed to reduce data resolution while maintaining uniqueness.
+ */
+export declare const ServerMetricSchemaBase: Schema.Struct<{
+    timestamp: typeof Schema.DateFromSelf;
+    pathname: typeof Schema.String;
+    route: typeof Schema.String;
+    name: Schema.Literal<["CLS", "INP", "LCP", "FCP", "TTFB"]>;
+    id: Schema.transformOrFail<typeof Schema.String, typeof Schema.String, never>;
+    value: Schema.refine<number, typeof Schema.Number>;
+    rating: Schema.Literal<["good", "needs-improvement", "poor"]>;
 }>;
+/**
+ * Schema for server-stored metrics, which includes all fields from the client-submitted metric along with a timestamp. The timestamp is generated on the server to indicate when the metric was processed, and the ID is transformed to reduce data resolution while maintaining uniqueness.
+ */
+export declare const ServerMetricSchema: Schema.transform<Schema.Struct<{
+    pathname: typeof Schema.String;
+    route: typeof Schema.String;
+    name: Schema.Literal<["CLS", "INP", "LCP", "FCP", "TTFB"]>;
+    id: Schema.transformOrFail<typeof Schema.String, typeof Schema.String, never>;
+    value: Schema.refine<number, typeof Schema.Number>;
+    rating: Schema.Literal<["good", "needs-improvement", "poor"]>;
+}>, Schema.Struct<{
+    timestamp: typeof Schema.DateFromSelf;
+    pathname: typeof Schema.String;
+    route: typeof Schema.String;
+    name: Schema.Literal<["CLS", "INP", "LCP", "FCP", "TTFB"]>;
+    id: Schema.transformOrFail<typeof Schema.String, typeof Schema.String, never>;
+    value: Schema.refine<number, typeof Schema.Number>;
+    rating: Schema.Literal<["good", "needs-improvement", "poor"]>;
+}>>;
 /** Type representing the shape of client-submitted metrics. */
-export type ClientMetric = z.input<typeof ClientMetricSchema>;
-export {};
+export type ClientMetric = typeof ClientMetricSchema.Type;

package/dist/plugins/analytics/schemas.js

@@ -1,20 +1,71 @@
-import { z } from "astro/zod";
-const RatingSchema = z.enum(["good", "needs-improvement", "poor"]);
-const MetricTypeSchema = z.enum(["CLS", "INP", "LCP", "FCP", "TTFB"]);
-const MetricIdSchema = z.string().regex(/^v5-\d{13}-\d{13}$/).transform((id) => id.replace(/^(v5-\d{8})\d{5}(-\d{13})$/, "$1$2"));
-const ClientMetricSchema = z.object({
-  pathname: z.string(),
-  route: z.string(),
+import { ParseResult } from "effect";
+import * as Schema from "effect/Schema";
+const RatingSchema = Schema.Literal("good", "needs-improvement", "poor");
+const MetricTypeSchema = Schema.Literal("CLS", "INP", "LCP", "FCP", "TTFB");
+const MetricIdSchema = Schema.transformOrFail(Schema.String, Schema.String, {
+  strict: true,
+  decode: (input, _options, ast) => {
+    if (typeof input !== "string") {
+      return ParseResult.fail(new ParseResult.Type(ast, input, "Expected a string for Metric ID"));
+    }
+    const regex = /^v5-\d{13}-\d{13}$/;
+    if (!regex.test(input)) {
+      return ParseResult.fail(
+        new ParseResult.Type(
+          ast,
+          input,
+          "Metric ID must match the pattern v5-<13 digits>-<13 digits>"
+        )
+      );
+    }
+    const transformedId = input.replace(/^(v5-\d{8})\d{5}(-\d{13})$/, "$1$2");
+    return ParseResult.succeed(transformedId);
+  },
+  encode: (input) => ParseResult.succeed(input)
+}).annotations({
+  title: "Metric ID",
+  identifier: "MetricId",
+  description: "A `web-vitals` generated ID, transformed to reduce data resolution."
+});
+const ClientMetricSchema = Schema.Struct({
+  pathname: Schema.String,
+  route: Schema.String,
   name: MetricTypeSchema,
   id: MetricIdSchema,
-  value: z.number().gte(0),
+  value: Schema.Number.pipe(Schema.greaterThan(0)).annotations({
+    description: "The value of the metric, must be a non-negative number."
+  }),
   rating: RatingSchema
+}).annotations({
+  title: "Client Metric",
+  identifier: "ClientMetric",
+  description: "Schema representing a client-submitted web performance metric, including its type, value, and associated metadata."
+});
+const ServerMetricSchemaBase = Schema.Struct({
+  ...ClientMetricSchema.fields,
+  timestamp: Schema.DateFromSelf
+}).annotations({
+  title: "Server Metric",
+  identifier: "ServerMetric",
+  description: "Schema representing a server-stored web performance metric, including all client-submitted fields and a timestamp indicating when the metric was processed."
 });
-const ServerMetricSchema = ClientMetricSchema.transform((metric) => {
-  const timestamp = /* @__PURE__ */ new Date();
-  timestamp.setMinutes(0, 0, 0);
-  return { ...metric, timestamp };
+const ServerMetricSchema = Schema.transform(ClientMetricSchema, ServerMetricSchemaBase, {
+  strict: true,
+  decode: (input) => {
+    const timestamp = /* @__PURE__ */ new Date();
+    timestamp.setMinutes(0, 0, 0);
+    return { ...input, timestamp };
+  },
+  encode: (input) => {
+    const { timestamp, ...rest } = input;
+    return rest;
+  }
 });
 export {
-  ServerMetricSchema
+  ClientMetricSchema,
+  MetricIdSchema,
+  MetricTypeSchema,
+  RatingSchema,
+  ServerMetricSchema,
+  ServerMetricSchemaBase
 };

package/dist/plugins/analytics/table.d.ts

@@ -32,8 +32,8 @@ export declare const StudioCMSMetricDBSchema: Schema.Struct<{
  */
 declare const StudioCMSMetricDBSchemaEncoded: {
     readonly StudioCMSMetric: {
-        readonly value: number;
         readonly name: "CLS" | "INP" | "LCP" | "FCP" | "TTFB";
+        readonly value: number;
         readonly route: string;
         readonly id: string;
         readonly timestamp: import("kysely").ColumnType<string, string, string>;

package/dist/plugins.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="./global.d.ts" preserve="true" />
 /// <reference types="./virtual.d.ts" preserve="true" />
 import type { APIContext } from 'astro';
 import type { CombinedPageData } from './virtuals/sdk/types.js';

package/dist/schemas/config/api.d.ts

@@ -0,0 +1,17 @@
+import * as Schema from 'effect/Schema';
+/**
+ * Schema for the API configuration, which includes settings for enabling or disabling the API documentation.
+ */
+export declare const ApiConfigSchema: Schema.Struct<{
+    apiDocs: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+}>;
+/**
+ * Type for the API configuration.
+ */
+export type ApiConfig = typeof ApiConfigSchema.Encoded;
+/**
+ * Resolved type for the API configuration.
+ */
+export type ApiConfigResolved = typeof ApiConfigSchema.Type;

package/dist/schemas/config/api.js

@@ -0,0 +1,14 @@
+import * as Schema from "effect/Schema";
+import { BooleanDefaultTrue } from "../custom.js";
+const ApiConfigSchema = Schema.Struct({
+  apiDocs: BooleanDefaultTrue.annotations({
+    description: "API Documentation - Allows enabling or disabling of the API documentation. These docs will be available at the /studiocms_api/docs route and provide an interactive interface for exploring the API specifications and endpoints. Disabling this option will hide the documentation route, which is recommended in production environments for security reasons."
+  })
+}).annotations({
+  title: "API Configuration",
+  description: "API Configuration - Configure the API settings for the dashboard",
+  identifier: "ApiConfig"
+});
+export {
+  ApiConfigSchema
+};

package/dist/schemas/config/auth.d.ts

@@ -1,64 +1,60 @@
-import { z } from 'astro/zod';
-export interface AuthConfig {
-    /** Auth Providers - Allows enabling or disabling of the Authentication Providers */
-    providers?: {
-        /** Username and Password Auth Provider */
-        usernameAndPassword?: boolean;
-        /**
-         * Username and Password Auth Provider Configuration
-         */
-        usernameAndPasswordConfig?: {
-            /**
-             * Allow User Registration - Allows users to register an account
-             *
-             * @default true
-             */
-            allowUserRegistration?: boolean;
+import * as Schema from 'effect/Schema';
+/**
+ * Schema for the username and password authentication provider configuration.
+ */
+export declare const UsernameAndPasswordConfigSchema: Schema.Struct<{
+    allowUserRegistration: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+}>;
+/**
+ * Schema for the authentication providers configuration.
+ */
+export declare const AuthProvidersConfigSchema: Schema.Struct<{
+    usernameAndPassword: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    usernameAndPasswordConfig: Schema.optionalWith<Schema.Schema<{
+        readonly allowUserRegistration: boolean;
+    }, {
+        readonly allowUserRegistration?: boolean | undefined;
+    }, never>, {
+        default: () => {
+            readonly allowUserRegistration: boolean;
         };
-    };
-    /**
-     * Auth Enabled - Allows enabling or disabling of the Authentication Configuration
-     *
-     * @default true
-     */
-    enabled?: boolean;
-}
-export declare const authConfigSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-    providers: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        usernameAndPassword: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        usernameAndPasswordConfig: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-            allowUserRegistration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        }, "strip", z.ZodTypeAny, {
-            allowUserRegistration: boolean;
-        }, {
-            allowUserRegistration?: boolean | undefined;
-        }>>>;
-    }, "strip", z.ZodTypeAny, {
-        usernameAndPassword: boolean;
-        usernameAndPasswordConfig: {
-            allowUserRegistration: boolean;
+    }>;
+}>;
+/**
+ * Schema for the authentication configuration.
+ */
+export declare const AuthConfigSchema: Schema.Struct<{
+    enabled: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    providers: Schema.optionalWith<Schema.Schema<{
+        readonly usernameAndPassword: boolean;
+        readonly usernameAndPasswordConfig: {
+            readonly allowUserRegistration: boolean;
         };
     }, {
-        usernameAndPassword?: boolean | undefined;
-        usernameAndPasswordConfig?: {
-            allowUserRegistration?: boolean | undefined;
+        readonly usernameAndPassword?: boolean | undefined;
+        readonly usernameAndPasswordConfig?: {
+            readonly allowUserRegistration?: boolean | undefined;
         } | undefined;
-    }>>>;
-    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    enabled: boolean;
-    providers: {
-        usernameAndPassword: boolean;
-        usernameAndPasswordConfig: {
-            allowUserRegistration: boolean;
+    }, never>, {
+        default: () => {
+            readonly usernameAndPassword: boolean;
+            readonly usernameAndPasswordConfig: {
+                readonly allowUserRegistration: boolean;
+            };
         };
-    };
-}, {
-    enabled?: boolean | undefined;
-    providers?: {
-        usernameAndPassword?: boolean | undefined;
-        usernameAndPasswordConfig?: {
-            allowUserRegistration?: boolean | undefined;
-        } | undefined;
-    } | undefined;
-}>>>;
+    }>;
+}>;
+/**
+ * Type for the authentication configuration.
+ */
+export type AuthConfig = typeof AuthConfigSchema.Encoded;
+/**
+ * Resolved type for the authentication configuration.
+ */
+export type AuthConfigResolved = typeof AuthConfigSchema.Type;

package/dist/schemas/config/auth.js

@@ -1,13 +1,36 @@
-import { z } from "astro/zod";
-const authConfigSchema = z.object({
-  providers: z.object({
-    usernameAndPassword: z.boolean().optional().default(true),
-    usernameAndPasswordConfig: z.object({
-      allowUserRegistration: z.boolean().optional().default(true)
-    }).optional().default({})
-  }).optional().default({}),
-  enabled: z.boolean().optional().default(true)
-}).optional().default({});
+import * as Schema from "effect/Schema";
+import { BooleanDefaultTrue, OptionalWithDefaults } from "../custom.js";
+const UsernameAndPasswordConfigSchema = Schema.Struct({
+  allowUserRegistration: BooleanDefaultTrue.annotations({
+    description: "Allow User Registration - Allows users to register an account"
+  })
+}).annotations({
+  title: "Username and Password Auth Provider Configuration",
+  description: "Username and Password Auth Provider Configuration",
+  identifier: "UsernameAndPasswordConfig"
+});
+const AuthProvidersConfigSchema = Schema.Struct({
+  usernameAndPassword: BooleanDefaultTrue.annotations({
+    description: "Username and Password Auth Provider"
+  }),
+  usernameAndPasswordConfig: OptionalWithDefaults(UsernameAndPasswordConfigSchema, {})
+}).annotations({
+  title: "Auth Providers",
+  description: "Auth Providers - Allows enabling or disabling of the Authentication Providers",
+  identifier: "AuthProvidersConfig"
+});
+const AuthConfigSchema = Schema.Struct({
+  enabled: BooleanDefaultTrue.annotations({
+    description: "Auth Enabled - Allows enabling or disabling of the Authentication Configuration"
+  }),
+  providers: OptionalWithDefaults(AuthProvidersConfigSchema, {})
+}).annotations({
+  title: "Authentication Configuration",
+  description: "Authentication Configuration",
+  identifier: "AuthConfig"
+});
 export {
-  authConfigSchema
+  AuthConfigSchema,
+  AuthProvidersConfigSchema,
+  UsernameAndPasswordConfigSchema
 };

package/dist/schemas/config/dashboard.d.ts

@@ -1,80 +1,44 @@
-import { z } from 'astro/zod';
-export interface DashboardConfig {
-    /** OPTIONAL - This allows the user to enable or disable the Astro StudioCMS dashboard but still provide all the helper's and utilities to those who are customizing their setup, doing so will disable the dashboard and you will need to manage your content via your database
-     *
-     * @default true
-     */
-    dashboardEnabled?: boolean;
-    /**
-     * OPTIONAL - This allows the user to enable or disable the default 404 route for the dashboard
-     *
-     * @default true
-     */
-    inject404Route?: boolean;
-    /**
-     * OPTIONAL - This allows the user to override the default Favicon URL to a custom URL
-     */
-    faviconURL?: string;
-    /**
-     * OPTIONAL - This allows the user to override the default dashboard route to a custom route
-     *
-     * **Note: Use with caution, this is an advanced feature**
-     *
-     * @usage - The default route is `dashboard` without any `/` or `\` characters. If you want to override the route to `/admin` you would set this value to `admin`
-     *
-     * @default "dashboard"
-     */
-    dashboardRouteOverride?: string;
-    /**
-     * OPTIONAL - This allows the user to enable or disable the version check for the dashboard
-     *
-     * This will check for the latest version of StudioCMS and notify the user
-     * if there is a new version available.
-     *
-     * @default true
-     */
-    versionCheck?: boolean;
-    /**
-     * OPTIONAL - This allows the user to configure security settings for the dashboard
-     */
-    security?: {
-        /**
-         * OPTIONAL - This allows the user to hide generator tags in the HTML output of the dashboard
-         *
-         * @default false
-         */
-        hideGeneratorTags?: boolean;
-    };
-}
-export declare const dashboardConfigSchema: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-    dashboardEnabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    inject404Route: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    faviconURL: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    dashboardRouteOverride: z.ZodOptional<z.ZodString>;
-    versionCheck: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    security: z.ZodDefault<z.ZodOptional<z.ZodObject<{
-        hideGeneratorTags: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, "strip", z.ZodTypeAny, {
-        hideGeneratorTags: boolean;
+import * as Schema from 'effect/Schema';
+/**
+ * Schema for the security configuration of the dashboard.
+ */
+export declare const SecurityConfigSchema: Schema.Struct<{
+    hideGeneratorTags: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+}>;
+/**
+ * Schema for the dashboard configuration.
+ */
+export declare const DashboardConfigSchema: Schema.Struct<{
+    dashboardEnabled: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    inject404Route: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    faviconURL: Schema.optionalWith<typeof Schema.NonEmptyTrimmedString, {
+        default: () => string;
+    }>;
+    dashboardRouteOverride: Schema.optional<typeof Schema.String>;
+    versionCheck: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    security: Schema.optionalWith<Schema.Schema<{
+        readonly hideGeneratorTags: boolean;
     }, {
-        hideGeneratorTags?: boolean | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    dashboardEnabled: boolean;
-    inject404Route: boolean;
-    faviconURL: string;
-    versionCheck: boolean;
-    security: {
-        hideGeneratorTags: boolean;
-    };
-    dashboardRouteOverride?: string | undefined;
-}, {
-    dashboardEnabled?: boolean | undefined;
-    inject404Route?: boolean | undefined;
-    faviconURL?: string | undefined;
-    dashboardRouteOverride?: string | undefined;
-    versionCheck?: boolean | undefined;
-    security?: {
-        hideGeneratorTags?: boolean | undefined;
-    } | undefined;
-}>>>;
+        readonly hideGeneratorTags?: boolean | undefined;
+    }, never>, {
+        default: () => {
+            readonly hideGeneratorTags: boolean;
+        };
+    }>;
+}>;
+/**
+ * Type for the dashboard configuration.
+ */
+export type DashboardConfig = typeof DashboardConfigSchema.Encoded;
+/**
+ * Resolved type for the dashboard configuration.
+ */
+export type DashboardConfigResolved = typeof DashboardConfigSchema.Type;

package/dist/schemas/config/dashboard.js

@@ -1,14 +1,45 @@
-import { z } from "astro/zod";
-const dashboardConfigSchema = z.object({
-  dashboardEnabled: z.boolean().optional().default(true),
-  inject404Route: z.boolean().optional().default(true),
-  faviconURL: z.string().optional().default("/favicon.svg"),
-  dashboardRouteOverride: z.string().optional(),
-  versionCheck: z.boolean().optional().default(true),
-  security: z.object({
-    hideGeneratorTags: z.boolean().optional().default(false)
-  }).optional().default({})
-}).optional().default({});
+import * as Schema from "effect/Schema";
+import {
+  BooleanDefaultFalse,
+  BooleanDefaultTrue,
+  OptionalWithDefaults,
+  StringWithDefault
+} from "../custom.js";
+const SecurityConfigSchema = Schema.Struct({
+  hideGeneratorTags: BooleanDefaultFalse.annotations({
+    description: "Hide Generator Tags - Hides generator tags in the HTML output of the dashboard"
+  })
+}).annotations({
+  title: "Dashboard Security Configuration",
+  description: "Configuration options related to the security of the dashboard",
+  identifier: "DashboardSecurityConfig"
+});
+const DashboardConfigSchema = Schema.Struct({
+  dashboardEnabled: BooleanDefaultTrue.annotations({
+    description: "Dashboard Enabled - Allows enabling or disabling of the dashboard"
+  }),
+  inject404Route: BooleanDefaultTrue.annotations({
+    description: "Inject 404 Route - Allows injecting a 404 route for the dashboard"
+  }),
+  faviconURL: StringWithDefault("/favicon.svg").annotations({
+    description: "Favicon URL - Allows overriding the default Favicon URL to a custom URL"
+  }),
+  dashboardRouteOverride: Schema.optional(Schema.String).annotations({
+    description: "Dashboard Route Override - Allows overriding the default dashboard route to a custom route",
+    usage: "The default route is `dashboard` without any `/` or `\\` characters. If you want to override the route to `/admin` you would set this value to `admin`"
+  }),
+  versionCheck: BooleanDefaultTrue.annotations({
+    description: "Version Check - Allows enabling or disabling of the version check for the dashboard"
+  }),
+  security: OptionalWithDefaults(SecurityConfigSchema, {}).annotations({
+    description: "Security Configuration - Allows configuring security settings for the dashboard"
+  })
+}).annotations({
+  title: "Dashboard Configuration",
+  description: "Configuration options related to the dashboard",
+  identifier: "DashboardConfig"
+});
 export {
-  dashboardConfigSchema
+  DashboardConfigSchema,
+  SecurityConfigSchema
 };