@arcote.tech/arc-adapter-db-sqlite-wasm 0.5.1 → 0.5.5

package/dist/index.js

@@ -1401,6 +1401,9 @@ class AuthAdapter {
         localStorage.removeItem(TOKEN_PREFIX + scope);
     }
   }
+  setDecoded(decoded, scope = "default") {
+    this.scopes.set(scope, { raw: "", decoded });
+  }
   loadPersisted() {
     if (!hasLocalStorage())
       return;
@@ -1598,7 +1601,8 @@ class EventWire {
           localId: e.localId,
           type: e.type,
           payload: e.payload,
-          createdAt: e.createdAt
+          createdAt: e.createdAt,
+          authContext: e.authContext
         }))
       }));
     }
@@ -1755,11 +1759,13 @@ class LocalEventPublisher {
   }
   async publish(event) {
     const allChanges = [];
+    const eventAuthContext = event.authContext ?? null;
     const storedEvent = {
       _id: event.id,
       type: event.type,
       payload: JSON.stringify(event.payload),
-      createdAt: event.createdAt.toISOString()
+      createdAt: event.createdAt.toISOString(),
+      authContext: eventAuthContext ? JSON.stringify(eventAuthContext) : null
     };
     allChanges.push({
       store: EVENT_TABLES.events,
@@ -2439,6 +2445,109 @@ class ArcObject extends ArcAbstract {
     return new ArcObject(partialShape);
   }
 }
+class DataStorage {
+  async commitChanges(changes) {
+    await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+  }
+}
+
+class ScopedStore {
+  #inner;
+  #restrictions;
+  #canWrite;
+  #storeName;
+  constructor(inner, restrictions, canWrite) {
+    this.#inner = inner;
+    this.#restrictions = restrictions;
+    this.#canWrite = canWrite;
+    this.#storeName = inner.storeName;
+  }
+  get storeName() {
+    return this.#storeName;
+  }
+  async find(options, listener) {
+    const restricted = this.#applyReadRestrictions(options);
+    return this.#inner.find(restricted, listener);
+  }
+  async set(item) {
+    this.#assertWriteAccess();
+    this.#validateScopeFields(item);
+    return this.#inner.set(item);
+  }
+  async remove(id) {
+    this.#assertWriteAccess();
+    return this.#inner.remove(id);
+  }
+  async modify(id, data) {
+    this.#assertWriteAccess();
+    this.#validateScopeFields(data);
+    return this.#inner.modify(id, data);
+  }
+  async applyChanges(changes) {
+    this.#assertWriteAccess();
+    for (const change of changes) {
+      if (change.type === "set") {
+        this.#validateScopeFields(change.data);
+      } else if (change.type === "modify") {
+        this.#validateScopeFields(change.data);
+      }
+    }
+    return this.#inner.applyChanges(changes);
+  }
+  unsubscribe(listener) {
+    this.#inner.unsubscribe(listener);
+  }
+  #applyReadRestrictions(options) {
+    if (Object.keys(this.#restrictions).length === 0) {
+      return options ?? {};
+    }
+    return {
+      ...options,
+      where: { ...options?.where ?? {}, ...this.#restrictions }
+    };
+  }
+  #assertWriteAccess() {
+    if (!this.#canWrite) {
+      throw new Error(`Scope violation: write access denied to store "${this.#storeName}" (read-only)`);
+    }
+  }
+  #validateScopeFields(data) {
+    for (const [key, value] of Object.entries(this.#restrictions)) {
+      if (key in data && data[key] !== value) {
+        throw new Error(`Scope violation: field "${key}" must be "${value}", got "${data[key]}" in store "${this.#storeName}"`);
+      }
+    }
+  }
+}
+
+class ScopedDataStorage extends DataStorage {
+  #inner;
+  #allowedStores;
+  #restrictions;
+  constructor(inner, allowedStores, restrictions) {
+    super();
+    this.#inner = inner;
+    this.#allowedStores = allowedStores;
+    this.#restrictions = restrictions;
+  }
+  getStore(storeName) {
+    const permission = this.#allowedStores.get(storeName);
+    if (!permission) {
+      throw new Error(`Scope violation: access denied to store "${storeName}" (not declared in query/mutate)`);
+    }
+    const inner = this.#inner.getStore(storeName);
+    return new ScopedStore(inner, this.#restrictions, permission === "read-write");
+  }
+  fork() {
+    return this.#inner.fork();
+  }
+  getReadTransaction() {
+    return this.#inner.getReadTransaction();
+  }
+  getReadWriteTransaction() {
+    return this.#inner.getReadWriteTransaction();
+  }
+}
 class ArcPrimitive extends ArcAbstract {
   serialize(value) {
     return value;
@@ -2623,6 +2732,54 @@ class ArcContextElement extends ArcFragmentBase {
     return this._seeds;
   }
 }
+function buildElementContext(queryElements, mutationElements, adapters) {
+  const queryMap = new Map;
+  const mutateMap = new Map;
+  const queryProps = {};
+  for (const element of queryElements) {
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      queryProps[element.name] = ctx;
+      queryMap.set(element, ctx);
+    }
+  }
+  const mutateProps = {};
+  for (const element of mutationElements) {
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      mutateProps[element.name] = ctx;
+      mutateMap.set(element, ctx);
+    }
+  }
+  const queryFn = (element) => {
+    const cached = queryMap.get(element);
+    if (cached)
+      return cached;
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      queryMap.set(element, ctx);
+      return ctx;
+    }
+    throw new Error(`Element "${element.name}" has no queryContext`);
+  };
+  Object.assign(queryFn, queryProps);
+  const mutateFn = (element) => {
+    const cached = mutateMap.get(element);
+    if (cached)
+      return cached;
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      mutateMap.set(element, ctx);
+      return ctx;
+    }
+    throw new Error(`Element "${element.name}" has no mutateContext`);
+  };
+  Object.assign(mutateFn, mutateProps);
+  return {
+    query: queryFn,
+    mutate: mutateFn
+  };
+}
 
 class ArcBoolean extends ArcPrimitive {
   hasToBeTrue() {
@@ -2746,11 +2903,14 @@ class ArcEvent extends ArcContextElement {
         if (!adapters.eventPublisher) {
           throw new Error(`Event "${this.data.name}" cannot be emitted: no eventPublisher adapter available`);
         }
+        const decoded = adapters.authAdapter?.getDecoded() ?? null;
+        const authContext = decoded ? { tokenName: decoded.tokenName, params: decoded.params } : null;
         const event = {
           type: this.data.name,
           payload,
           id: this.eventId.generate(),
-          createdAt: new Date
+          createdAt: new Date,
+          authContext
         };
         await adapters.eventPublisher.publish(event);
       }
@@ -2826,55 +2986,6 @@ class ArcEvent extends ArcContextElement {
     return ArcEvent.sharedDatabaseStoreSchema();
   }
 }
-function buildElementContext(queryElements, mutationElements, adapters) {
-  const queryMap = new Map;
-  const mutateMap = new Map;
-  const queryProps = {};
-  for (const element of queryElements) {
-    if (element.queryContext) {
-      const ctx = element.queryContext(adapters);
-      queryProps[element.name] = ctx;
-      queryMap.set(element, ctx);
-    }
-  }
-  const mutateProps = {};
-  for (const element of mutationElements) {
-    if (element.mutateContext) {
-      const ctx = element.mutateContext(adapters);
-      mutateProps[element.name] = ctx;
-      mutateMap.set(element, ctx);
-    }
-  }
-  const queryFn = (element) => {
-    const cached = queryMap.get(element);
-    if (cached)
-      return cached;
-    if (element.queryContext) {
-      const ctx = element.queryContext(adapters);
-      queryMap.set(element, ctx);
-      return ctx;
-    }
-    throw new Error(`Element "${element.name}" has no queryContext`);
-  };
-  Object.assign(queryFn, queryProps);
-  const mutateFn = (element) => {
-    const cached = mutateMap.get(element);
-    if (cached)
-      return cached;
-    if (element.mutateContext) {
-      const ctx = element.mutateContext(adapters);
-      mutateMap.set(element, ctx);
-      return ctx;
-    }
-    throw new Error(`Element "${element.name}" has no mutateContext`);
-  };
-  Object.assign(mutateFn, mutateProps);
-  return {
-    query: queryFn,
-    mutate: mutateFn
-  };
-}
-
 class ArcFunction {
   data;
   constructor(data) {
@@ -2991,11 +3102,14 @@ class AggregateBase {
           if (!adapters.eventPublisher) {
             throw new Error(`Cannot emit event "${arcEvent.name}": no eventPublisher adapter available`);
           }
+          const decoded = adapters.authAdapter?.getDecoded() ?? null;
+          const authContext = decoded ? { tokenName: decoded.tokenName, params: decoded.params } : null;
           const eventInstance = {
             type: arcEvent.name,
             payload,
             id: `${Date.now()}_${Math.random().toString(36).slice(2)}`,
-            createdAt: new Date
+            createdAt: new Date,
+            authContext
           };
           await adapters.eventPublisher.publish(eventInstance);
         }
@@ -3191,9 +3305,10 @@ class ArcListener extends ArcContextElement {
   async handleEvent(event2, adapters) {
     if (!this.data.handler)
       return;
-    const context2 = this.#fn.buildContext(adapters);
-    if (adapters.authAdapter) {
-      const decoded = adapters.authAdapter.getDecoded();
+    const scopedAdapters = this.buildScopedAdapters(event2, adapters);
+    const context2 = this.#fn.buildContext(scopedAdapters);
+    if (scopedAdapters.authAdapter) {
+      const decoded = scopedAdapters.authAdapter.getDecoded();
       if (decoded) {
         context2.$auth = {
           params: decoded.params,
@@ -3209,6 +3324,21 @@ class ArcListener extends ArcContextElement {
       await this.data.handler(context2, event2);
     }
   }
+  buildScopedAdapters(event2, adapters) {
+    if (adapters.authAdapter?.isAuthenticated()) {
+      return adapters;
+    }
+    const authContext = event2.authContext;
+    if (!authContext) {
+      return adapters;
+    }
+    const scopedAuth = new AuthAdapter;
+    scopedAuth.setDecoded({
+      tokenName: authContext.tokenName,
+      params: authContext.params
+    });
+    return { ...adapters, authAdapter: scopedAuth };
+  }
   destroy() {
     for (const unsubscribe of this.unsubscribers) {
       unsubscribe();
@@ -3313,12 +3443,6 @@ class ArcRoute extends ArcContextElement {
     return context2;
   }
 }
-class DataStorage {
-  async commitChanges(changes) {
-    await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
-  }
-}
-
 class StoreState {
   storeName;
   dataStorage;
@@ -4339,7 +4463,8 @@ class StreamingEventPublisher {
         localId: event3.id,
         type: event3.type,
         payload: event3.payload,
-        createdAt: event3.createdAt.toISOString()
+        createdAt: event3.createdAt.toISOString(),
+        authContext: event3.authContext ?? null
       }
     ]);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-sqlite-wasm",
-  "version": "0.5.1",
+  "version": "0.5.5",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     "dev": "bun build ./src/index.ts ./src/worker.ts --outdir ./dist --target browser --format esm --watch"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.5.1",
+    "@arcote.tech/arc": "^0.5.5",
     "@sqlite.org/sqlite-wasm": "^3.46.0-build1"
   },
   "devDependencies": {