@arcote.tech/platform 0.4.6 → 0.4.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/platform",
   "type": "module",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc Platform — module system, router, layout, theme, i18n, platform app shell",
@@ -18,11 +18,11 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@arcote.tech/arc-ds": "^0.4.6",
-    "@arcote.tech/arc-react": "^0.4.6"
+    "@arcote.tech/arc-ds": "^0.4.7",
+    "@arcote.tech/arc-react": "^0.4.7"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.4.6",
+    "@arcote.tech/arc": "^0.4.7",
     "@lingui/core": "^5.0.0",
     "@lingui/react": "^5.0.0",
     "framer-motion": "^12.0.0",

package/src/arc.ts

@@ -8,6 +8,7 @@ import type {
   BuiltModule,
   ContextElementFragment,
   ExtractPages,
+  ModuleAccessRule,
   PageFragment,
   PageOptions,
   SlotFragment,
@@ -148,9 +149,22 @@ class ModuleBuilder<
   private _pages: Record<string, string> | undefined;
   private _ctx: { elements: readonly ArcContextElementAny[] } | undefined;
   private _scope: string | undefined;
+  private _protectedBy: ModuleAccessRule[] = [];
 
   constructor(readonly name: string) {}
 
+  /**
+   * Restrict module loading to users holding the given token.
+   * Optional check function for granular access control.
+   */
+  protectedBy(
+    token: { name: string },
+    check?: (tokenInstance: any) => boolean | Promise<boolean>,
+  ): this {
+    this._protectedBy.push({ token, check });
+    return this;
+  }
+
   /**
    * Register the module's ArcContext and scope name.
    * Context element fragments are auto-injected in build().
@@ -225,12 +239,14 @@ class ModuleBuilder<
 
     const mod: Record<string, unknown> = {
       id: moduleId,
+      name: this.name,
       fragments: allFragments,
       publicFragments: this._public,
       pages: Object.freeze(this._pages ?? {}),
     };
     if (this._ctx !== undefined) mod.context = this._ctx;
     if (this._scope !== undefined) mod.scope = this._scope;
+    if (this._protectedBy.length > 0) mod.access = { rules: this._protectedBy };
     if (domain) Object.assign(mod, domain);
 
     registerModule(mod as unknown as ArcModule);
@@ -285,12 +301,13 @@ export function arc(
   // Context registration: factory returned an ArcContext
   if (isArcContext(result)) {
     setContext(result);
-    return { id: moduleId, fragments: [], publicFragments: [] };
+    return { id: moduleId, name: moduleId, fragments: [], publicFragments: [] };
   }
 
   const publicFragments: readonly ArcFragment[] = Array.isArray(result) ? result : [];
   const mod: ArcModule = {
     id: moduleId,
+    name: moduleId,
     fragments: allFragments,
     publicFragments,
   };

package/src/index.ts

@@ -8,8 +8,10 @@ export {
   clearModules,
   clearRegistry,
   getAllFragments,
+  getAllModuleAccess,
   getAllModules,
   getContext,
+  getModuleAccess,
   getContextElementFragments,
   getDefaultLayout,
   getModule,
@@ -106,6 +108,9 @@ export type {
   ArcModule,
   BuiltModule,
   ContextElementFragment,
+  ModuleAccess,
+  ModuleAccessRule,
+  ModuleDescriptor,
   ExtractPages,
   FragmentOrdering,
   PageFragment,

package/src/module-loader.ts

@@ -1,27 +1,51 @@
 import { clearModules, getContext } from "./registry";
+import type { ModuleDescriptor } from "./types";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 export interface ModuleManifest {
-  modules: string[];
+  modules: ModuleDescriptor[];
   buildTime: string;
 }
 
 export type ModuleLoaderState = "loading" | "ready" | "error";
 
+function moduleUrl(baseUrl: string, mod: ModuleDescriptor, bust?: string): string {
+  const base = mod.url ?? `${baseUrl}/modules/${mod.file}`;
+  return bust ? `${base}${base.includes("?") ? "&" : "?"}t=${bust}` : base;
+}
+
+/** Read first available arc token from localStorage */
+function getPersistedToken(): string | null {
+  if (typeof localStorage === "undefined") return null;
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (key?.startsWith("arc:token:")) {
+      return localStorage.getItem(key);
+    }
+  }
+  return null;
+}
+
 /**
- * Load all modules from manifest. Each module auto-registers via arc().
+ * Load all modules from manifest. Each module auto-registers via module().build().
  */
-export async function loadModules(baseUrl: string): Promise<ModuleManifest> {
-  const res = await fetch(`${baseUrl}/api/modules`);
+export async function loadModules(
+  baseUrl: string,
+  token?: string | null,
+): Promise<ModuleManifest> {
+  const resolvedToken = token ?? getPersistedToken();
+  const headers: HeadersInit = {};
+  if (resolvedToken) headers["Authorization"] = `Bearer ${resolvedToken}`;
+
+  const res = await fetch(`${baseUrl}/api/modules`, { headers });
   if (!res.ok)
     throw new Error(`Failed to fetch module manifest: ${res.status}`);
 
   const manifest: ModuleManifest = await res.json();
 
-  // Import all modules — each calls arc() which auto-registers
   await Promise.all(
     manifest.modules.map(
-      (mod) => import(/* @vite-ignore */ `${baseUrl}/modules/${mod}`),
+      (mod) => import(/* @vite-ignore */ moduleUrl(baseUrl, mod)),
     ),
   );
 
@@ -31,19 +55,26 @@ export async function loadModules(baseUrl: string): Promise<ModuleManifest> {
 /**
  * Reload modules — clear registry, re-import with cache bust.
  */
-export async function reloadModules(baseUrl: string): Promise<ModuleManifest> {
+export async function reloadModules(
+  baseUrl: string,
+  token?: string | null,
+): Promise<ModuleManifest> {
   clearModules();
 
-  const res = await fetch(`${baseUrl}/api/modules`);
+  const resolvedToken = token ?? getPersistedToken();
+  const headers: HeadersInit = {};
+  if (resolvedToken) headers["Authorization"] = `Bearer ${resolvedToken}`;
+
+  const res = await fetch(`${baseUrl}/api/modules`, { headers });
   if (!res.ok)
     throw new Error(`Failed to fetch module manifest: ${res.status}`);
 
   const manifest: ModuleManifest = await res.json();
-  const bust = `?t=${Date.now()}`;
+  const bust = String(Date.now());
 
   await Promise.all(
     manifest.modules.map(
-      (mod) => import(/* @vite-ignore */ `${baseUrl}/modules/${mod}${bust}`),
+      (mod) => import(/* @vite-ignore */ moduleUrl(baseUrl, mod, bust)),
     ),
   );
 
@@ -52,32 +83,35 @@ export async function reloadModules(baseUrl: string): Promise<ModuleManifest> {
 
 /**
  * Hook: loads modules on mount, provides state + context.
+ * Re-fetches manifest when token changes (login/logout).
  */
 export function useModuleLoader(
   baseUrl: string,
-  options: { skip?: boolean } = {},
+  options: { skip?: boolean; token?: string | null } = {},
 ) {
   const [state, setState] = useState<ModuleLoaderState>(
     options.skip ? "ready" : "loading",
   );
   const [error, setError] = useState<Error | null>(null);
   const loaded = useRef(false);
+  const prevToken = useRef(options.token);
 
   const reload = useCallback(async () => {
     try {
-      await reloadModules(baseUrl);
+      await reloadModules(baseUrl, options.token);
       setState("ready");
     } catch (e) {
       setError(e instanceof Error ? e : new Error(String(e)));
       setState("error");
     }
-  }, [baseUrl]);
+  }, [baseUrl, options.token]);
 
+  // Initial load
   useEffect(() => {
     if (options.skip || loaded.current) return;
     loaded.current = true;
 
-    loadModules(baseUrl)
+    loadModules(baseUrl, options.token)
       .then(() => setState("ready"))
       .catch((e) => {
         setError(e instanceof Error ? e : new Error(String(e)));
@@ -96,7 +130,15 @@ export function useModuleLoader(
     };
 
     return () => evtSource.close();
-  }, [baseUrl, reload, options.skip]);
+  }, [baseUrl, reload, options.skip, options.token]);
+
+  // Reload on token change (login/logout)
+  useEffect(() => {
+    if (!loaded.current) return;
+    if (prevToken.current === options.token) return;
+    prevToken.current = options.token;
+    reload();
+  }, [options.token, reload]);
 
   return { state, error, context: getContext(), reload };
 }

package/src/platform-app.tsx

@@ -1,6 +1,6 @@
 import type { ArcContextAny } from "@arcote.tech/arc";
 import type { DSVariantOverrides } from "@arcote.tech/arc-ds";
-import { DesignSystemProvider } from "@arcote.tech/arc-ds";
+import { DesignSystemProvider, TooltipProvider } from "@arcote.tech/arc-ds";
 import { reactModel } from "@arcote.tech/arc-react";
 import { Layout } from "@arcote.tech/arc-ds";
 import { ArcLayoutProvider } from "./layout/layout-provider";
@@ -13,13 +13,10 @@ import {
   setDefaultLayout,
 } from "./registry";
 import { ThemeProvider } from "./theme";
-import { Tooltip as RadixTooltip } from "radix-ui";
 import { useEffect, useMemo, useState } from "react";
 import { useModuleLoader } from "./module-loader";
 import { PlatformModelProvider } from "./platform-context";
 
-const TooltipProvider = RadixTooltip.Provider;
-
 export interface PlatformAppProps {
   apiUrl?: string;
   wsUrl?: string;

package/src/registry.ts

@@ -3,6 +3,7 @@ import type {
   ArcLayoutComponent,
   ArcModule,
   ContextElementFragment,
+  ModuleAccess,
   PageFragment,
   SlotFragment,
   SlotId,
@@ -186,6 +187,23 @@ export function getWrapperFragments(): WrapperFragment[] {
   return sortByOrdering(fragments);
 }
 
+/** Get access rules for a module by name. */
+export function getModuleAccess(name: string): ModuleAccess | undefined {
+  for (const mod of modules.values()) {
+    if (mod.name === name && mod.access) return mod.access;
+  }
+  return undefined;
+}
+
+/** Get access rules for all protected modules. */
+export function getAllModuleAccess(): Map<string, ModuleAccess> {
+  const result = new Map<string, ModuleAccess>();
+  for (const mod of modules.values()) {
+    if (mod.access) result.set(mod.name, mod.access);
+  }
+  return result;
+}
+
 /** Clear all modules (but keep context). Used for reload. */
 export function clearModules(): void {
   modules.clear();

package/src/types.ts

@@ -83,14 +83,35 @@ export type ArcFragment =
 
 export type PublicArcFragment = ArcFragment;
 
+// ---------------------------------------------------------------------------
+// Module access control
+// ---------------------------------------------------------------------------
+
+export interface ModuleAccessRule {
+  readonly token: { name: string; [key: string]: any };
+  readonly check?: (tokenInstance: any) => boolean | Promise<boolean>;
+}
+
+export interface ModuleAccess {
+  readonly rules: readonly ModuleAccessRule[];
+}
+
+export interface ModuleDescriptor {
+  readonly file: string;
+  readonly name: string;
+  readonly url?: string;
+}
+
 // ---------------------------------------------------------------------------
 // Moduł
 // ---------------------------------------------------------------------------
 
 export interface ArcModule {
   readonly id: string;
+  readonly name: string;
   readonly fragments: readonly ArcFragment[];
   readonly publicFragments: readonly ArcFragment[];
+  readonly access?: ModuleAccess;
 }
 
 // ---------------------------------------------------------------------------