studiocms 0.3.0 → 0.4.0

package/dist/handlers/routeHandler.js

@@ -1,17 +1,38 @@
-import { Effect, runEffect } from "@withstudiocms/effect";
-import { defineUtility } from "astro-integration-kit";
-import { getAstroProject, StudioCMSRouteConfig } from "./frontend/routes.js";
+import { Effect } from "@withstudiocms/effect";
+import { addVirtualImports, defineUtility } from "astro-integration-kit";
+import {
+  getAstroProject,
+  getRouteConfig,
+  StudioCMSRouteConfig
+} from "./frontend/routes.js";
 const routeHandler = defineUtility("astro:config:setup")(
   async (params, options) => {
     const { injectRoute, addMiddleware } = params;
-    const projectEffect = getAstroProject.pipe(Effect.provide(StudioCMSRouteConfig.Live(options)));
-    const { routes, middleware } = await runEffect(projectEffect);
-    for (const route of routes) {
-      injectRoute(route);
-    }
-    for (const mw of middleware) {
-      addMiddleware(mw);
-    }
+    const _injectRoutes = (route) => Effect.sync(() => injectRoute(route));
+    const _addMiddleware = (mw) => Effect.sync(() => addMiddleware(mw));
+    const sharedConfig = StudioCMSRouteConfig.Live(options);
+    await Effect.all([
+      // Retrieve the processed route configuration and add it as a virtual import for use in other parts of the application
+      getRouteConfig.pipe(
+        Effect.map((config) => {
+          addVirtualImports(params, {
+            name: "studiocms:routeHandler",
+            imports: {
+              "virtual:studiocms/route-config": `export const routeConfig = ${JSON.stringify(config)}; export default routeConfig;`
+            }
+          });
+        })
+      ),
+      // Retrieve the Astro project configuration, which includes the routes and middleware to be injected, and process them by injecting routes and adding middleware
+      getAstroProject.pipe(
+        Effect.flatMap(
+          ({ middleware, routes }) => Effect.all([
+            Effect.forEach(routes, _injectRoutes),
+            Effect.forEach(middleware, _addMiddleware)
+          ])
+        )
+      )
+    ]).pipe(Effect.provide(sharedConfig), Effect.runPromise);
   }
 );
 export {

package/dist/handlers/setupDbStudio.d.ts

@@ -1,3 +1,3 @@
 export declare const setupDbStudio: import("astro-integration-kit").HookUtility<"astro:config:setup", [opts: {
-    dialect: "libsql" | "postgres" | "mysql";
+    readonly dialect: "libsql" | "postgres" | "mysql";
 }], Promise<void>>;

package/dist/handlers/storage-manager/core/effectify-astro-context.d.ts

@@ -0,0 +1,25 @@
+import { HttpServerResponse } from '@effect/platform';
+import type { HttpBodyError } from '@effect/platform/HttpBody';
+import type { APIContext } from 'astro';
+import type { Effect } from 'effect';
+import type { ContextDriverDefinition, ContextHandler, ContextHandlerFn, ParsedContext } from '../definitions';
+/**
+ * Astro Context Driver implementation.
+ *
+ * This class implements the ContextDriverDefinition interface for Astro,
+ * providing methods to parse the context, build responses, and handle endpoints.
+ */
+export default class EffectifyAstroContextDriver implements ContextDriverDefinition<APIContext, Effect.Effect<HttpServerResponse.HttpServerResponse, HttpBodyError>> {
+    parseContext({ request, locals }: APIContext): ParsedContext;
+    buildResponse<Data>(opts: {
+        data: Data;
+        status: number;
+    }): Effect.Effect<HttpServerResponse.HttpServerResponse, HttpBodyError>;
+    buildErrorResponse(error: unknown): {
+        data: {
+            error: string;
+        };
+        status: number;
+    };
+    handleEndpoint(contextHandler: ContextHandler): ContextHandlerFn<APIContext, Effect.Effect<HttpServerResponse.HttpServerResponse, HttpBodyError>>;
+}

package/dist/handlers/storage-manager/core/effectify-astro-context.js

@@ -0,0 +1,78 @@
+import { runSDK, SDKCoreJs } from "studiocms:sdk";
+import { HttpServerResponse } from "@effect/platform";
+import { UserPermissionLevel } from "@withstudiocms/auth-kit/types";
+class EffectifyAstroContextDriver {
+  parseContext({ request, locals }) {
+    return {
+      getJson: () => request.json(),
+      getArrayBuffer: () => request.arrayBuffer(),
+      getHeader: (name) => request.headers.get(name),
+      isAuthorized: async (type) => {
+        switch (type) {
+          case "headers": {
+            const authTokenData = request.headers.get("Authorization");
+            if (!authTokenData) {
+              return false;
+            }
+            const parts = authTokenData.split(" ");
+            if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+              return false;
+            }
+            const token = parts[1];
+            const user = await runSDK(SDKCoreJs.REST_API.tokens.verify(token));
+            if (!user) {
+              return false;
+            }
+            let level;
+            switch (user.rank) {
+              case "owner":
+                level = UserPermissionLevel.owner;
+                break;
+              case "admin":
+                level = UserPermissionLevel.admin;
+                break;
+              case "editor":
+                level = UserPermissionLevel.editor;
+                break;
+              case "visitor":
+                level = UserPermissionLevel.visitor;
+                break;
+              default:
+                level = UserPermissionLevel.unknown;
+            }
+            const isEditor = level >= UserPermissionLevel.editor;
+            if (!isEditor) {
+              return false;
+            }
+            return true;
+          }
+          default: {
+            const isEditor = locals.StudioCMS.security?.userPermissionLevel.isEditor || false;
+            return isEditor;
+          }
+        }
+      }
+    };
+  }
+  buildResponse(opts) {
+    return HttpServerResponse.json(opts.data, { status: opts.status });
+  }
+  buildErrorResponse(error) {
+    return { data: { error: error.message }, status: 500 };
+  }
+  handleEndpoint(contextHandler) {
+    return async (rawContext) => {
+      try {
+        const context = this.parseContext(rawContext);
+        const opts = await contextHandler(context);
+        return this.buildResponse(opts);
+      } catch (error) {
+        const errorResponse = this.buildErrorResponse(error);
+        return this.buildResponse(errorResponse);
+      }
+    };
+  }
+}
+export {
+  EffectifyAstroContextDriver as default
+};

package/dist/handlers/storage-manager/no-op.d.ts

@@ -1,4 +1,4 @@
-import { type StudioCMSStorageManager } from '../../schemas/index.js';
+import { type StudioCMSStorageManagerDef } from '../../schemas/index.js';
 /**
  * Defines a No-Op Storage Manager plugin for StudioCMS.
  *
@@ -7,4 +7,4 @@ import { type StudioCMSStorageManager } from '../../schemas/index.js';
  * @param version - The minimum StudioCMS version required for this storage manager.
  * @returns A StudioCMSStorageManager plugin definition.
  */
-export declare const NoOpStorageManager: (version: string) => StudioCMSStorageManager;
+export declare const NoOpStorageManager: () => StudioCMSStorageManagerDef;

package/dist/handlers/storage-manager/no-op.js

@@ -1,12 +1,11 @@
 import createPathResolver from "@withstudiocms/internal_helpers/pathResolver";
 import { defineStorageManager } from "../../schemas/index.js";
 const { resolve } = createPathResolver(import.meta.url);
-const NoOpStorageManager = (version) => defineStorageManager({
+const NoOpStorageManager = () => defineStorageManager({
   identifier: "studiocms",
   name: "Core No-Op Storage (built-in)",
-  studiocmsMinimumVersion: version,
   hooks: {
-    "studiocms:storage-manager": ({ setStorageManager, logger }) => {
+    "studiocms:storage-manager": async ({ setStorageManager, logger }) => {
       logger.info("No-Op Storage initialized.");
       setStorageManager({
         managerPath: resolve("./core/no-op-storage-manager.js")

package/dist/index.d.ts

@@ -4,7 +4,6 @@
  * directives must be first at the top of the file and can only be preceded by this comment.
  */
 /// <reference types="@studiocms/ui/v/types" preserve="true" />
-/// <reference types="./global.d.ts" preserve="true" />
 /// <reference types="./virtual.d.ts" preserve="true" />
 /// <reference types="./theme.d.ts" preserve="true" />
 import type { AstroIntegration } from 'astro';

package/dist/index.js

@@ -2,7 +2,11 @@ import { promises as fsP, writeFileSync } from "node:fs";
 import { runtimeLogger } from "@inox-tools/runtime-logger";
 import studiocmsUi from "@studiocms/ui";
 import { componentRegistryHandler } from "@withstudiocms/component-registry";
-import { configResolverBuilder, exists, watchConfigFileBuilder } from "@withstudiocms/config-utils";
+import {
+  configResolverBuilderEffect,
+  exists,
+  watchConfigFileBuilder
+} from "@withstudiocms/config-utils";
 import { Effect, runEffect } from "@withstudiocms/effect";
 import {
   addIntegrationArray,
@@ -58,10 +62,10 @@ const studiocms = () => {
   const watchConfigFile = watchConfigFileBuilder({
     configPaths
   });
-  const configResolver = configResolverBuilder({
+  const configResolver = configResolverBuilderEffect({
     configPaths,
     label: name,
-    zodSchema: StudioCMSOptionsSchema
+    effectSchema: StudioCMSOptionsSchema
   });
   const messages = [];
   let cacheJsonFile;
@@ -133,7 +137,6 @@ const studiocms = () => {
           dashboardRoute,
           dbStartPage,
           name,
-          pkgVersion,
           plugins,
           robotsTXTConfig,
           verbose,
@@ -242,7 +245,8 @@ const studiocms = () => {
             "studiocms:debug-info": `export const debugInfo = ${JSON.stringify(debugOutput)};export default debugInfo;`,
             "studiocms:client-scripts/StorageFileBrowser": ambientScripts([
               "./virtuals/scripts/StorageFileBrowser.js"
-            ])
+            ]),
+            "studiocms:client/apiClients": dynamicVirtual(["./client/apiClient.js"])
           }
         });
         await setupDbStudio(params, options.db);

package/dist/integrations/robots/index.d.ts

@@ -1,5 +1,5 @@
 import type { AstroIntegration } from 'astro';
-import { type RobotsConfig } from './schema.js';
+import type { RobotsConfig } from './schema.js';
 /**
  * **Robots.txt Integration**
  *
@@ -8,4 +8,4 @@ import { type RobotsConfig } from './schema.js';
  * @param astroConfig Robots Configuration
  * @returns AstroIntegration
  */
-export default function createRobotsIntegration(options: RobotsConfig): AstroIntegration;
+export default function createRobotsIntegration(config: RobotsConfig): AstroIntegration;

package/dist/integrations/robots/index.js

@@ -1,13 +1,11 @@
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { generateContent, printInfo } from "./core.js";
-import { RobotsTXTConfigSchema } from "./schema.js";
 import { getFileSizeInKilobytes, measureExecutionTime } from "./utils.js";
-function createRobotsIntegration(options) {
+function createRobotsIntegration(config) {
   let astroConfig;
   let finalSiteMapHref;
   let executionTime;
-  const config = RobotsTXTConfigSchema.parse(options);
   return {
     name: "studiocms/robotstxt",
     hooks: {