@arcote.tech/arc-adapter-db-sqlite 0.4.7 → 0.5.0

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/bun-sqlite.ts
 import { Database } from "bun:sqlite";
 
-// ../../../../node_modules/mutative/dist/mutative.esm.mjs
+// ../../../../node_modules/.bun/mutative@1.3.0/node_modules/mutative/dist/mutative.esm.mjs
 var Operation = {
   Remove: "remove",
   Replace: "replace",
@@ -1357,14 +1357,23 @@ var TOKEN_PREFIX = "arc:token:";
 function hasLocalStorage() {
   return typeof localStorage !== "undefined";
 }
+function notifyTokenChange(scope) {
+  if (typeof window !== "undefined") {
+    queueMicrotask(() => {
+      window.dispatchEvent(new CustomEvent("arc:token-change", { detail: { scope } }));
+    });
+  }
+}
 
 class AuthAdapter {
   scopes = new Map;
   setToken(token, scope = "default") {
     if (!token) {
       this.scopes.delete(scope);
-      if (hasLocalStorage())
+      if (hasLocalStorage()) {
         localStorage.removeItem(TOKEN_PREFIX + scope);
+        notifyTokenChange(scope);
+      }
       return;
     }
     try {
@@ -1385,8 +1394,10 @@ class AuthAdapter {
           exp: payload.exp
         }
       });
-      if (hasLocalStorage())
+      if (hasLocalStorage()) {
         localStorage.setItem(TOKEN_PREFIX + scope, token);
+        notifyTokenChange(scope);
+      }
     } catch {
       this.scopes.delete(scope);
       if (hasLocalStorage())
@@ -2818,6 +2829,147 @@ 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) {
+    this.data = data;
+  }
+  withParams(schema) {
+    return new ArcFunction({
+      ...this.data,
+      params: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    });
+  }
+  withResult(schema) {
+    return new ArcFunction({
+      ...this.data,
+      result: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    });
+  }
+  query(elements) {
+    return new ArcFunction({
+      ...this.data,
+      queryElements: elements
+    });
+  }
+  mutate(elements) {
+    return new ArcFunction({
+      ...this.data,
+      mutationElements: elements
+    });
+  }
+  protectedBy(token, check) {
+    const existingProtections = this.data.protections || [];
+    return new ArcFunction({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    });
+  }
+  description(desc) {
+    return new ArcFunction({
+      ...this.data,
+      description: desc
+    });
+  }
+  handle(handler) {
+    return new ArcFunction({
+      ...this.data,
+      handler
+    });
+  }
+  get isPublic() {
+    return !this.hasProtections;
+  }
+  get hasProtections() {
+    return (this.data.protections?.length ?? 0) > 0;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  get handler() {
+    return this.data.handler;
+  }
+  get params() {
+    return this.data.params;
+  }
+  get result() {
+    return this.data.result;
+  }
+  async verifyProtections(tokens) {
+    if (!this.data.protections || this.data.protections.length === 0) {
+      return true;
+    }
+    for (const protection of this.data.protections) {
+      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
+      if (!tokenInstance) {
+        return false;
+      }
+      const result = await protection.check(tokenInstance);
+      if (result === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+  buildContext(adapters) {
+    return buildElementContext(this.data.queryElements || [], this.data.mutationElements || [], adapters);
+  }
+  toJsonSchema() {
+    return {
+      params: this.data.params?.toJsonSchema?.() ?? null,
+      result: this.data.result?.toJsonSchema?.() ?? null
+    };
+  }
+}
 class AggregateBase {
   value;
   _id;
@@ -2855,6 +3007,315 @@ class AggregateBase {
     return result;
   }
 }
+class ArcCommand extends ArcContextElement {
+  data;
+  #fn;
+  constructor(data, fn) {
+    super(data.name);
+    this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: data.params,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: data.protections || [],
+      handler: data.handler ?? null,
+      description: data.description
+    });
+  }
+  description(description) {
+    const newFn = this.#fn.description(description);
+    return new ArcCommand({ ...this.data, description }, newFn);
+  }
+  get isPublic() {
+    return this.#fn.isPublic;
+  }
+  query(elements) {
+    const newFn = this.#fn.query(elements);
+    return new ArcCommand({ ...this.data, queryElements: elements }, newFn);
+  }
+  mutate(elements) {
+    const newFn = this.#fn.mutate(elements);
+    return new ArcCommand({ ...this.data, mutationElements: elements }, newFn);
+  }
+  withParams(schema) {
+    const newFn = this.#fn.withParams(schema);
+    return new ArcCommand({
+      ...this.data,
+      params: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    }, newFn);
+  }
+  withResult(...schemas) {
+    return new ArcCommand({ ...this.data, results: schemas }, this.#fn);
+  }
+  handle(handler) {
+    const newFn = new ArcFunction({
+      ...this.#fn.data,
+      handler
+    });
+    return new ArcCommand({ ...this.data, handler }, newFn);
+  }
+  protectBy(token, check) {
+    const newFn = this.#fn.protectedBy(token, check);
+    const existingProtections = this.data.protections || [];
+    return new ArcCommand({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    }, newFn);
+  }
+  get hasProtections() {
+    return this.#fn.hasProtections;
+  }
+  get protections() {
+    return this.#fn.protections;
+  }
+  async verifyProtections(tokens) {
+    return this.#fn.verifyProtections(tokens);
+  }
+  async init(environment, adapters) {
+    if (environment === "server" && this.data.handler && adapters.commandWire?.registerCommandHandler) {
+      adapters.commandWire.registerCommandHandler(this.data.name, async (params) => {
+        const executeFunc = this.mutateContext(adapters);
+        return await executeFunc(params);
+      });
+    }
+  }
+  mutateContext(adapters) {
+    const executeFunc = async (params) => {
+      if (this.data.handler) {
+        return await this.executeLocally(params, adapters);
+      }
+      if (!adapters.commandWire) {
+        throw new Error(`Command "${this.data.name}" has no handler and no commandWire adapter available for remote execution`);
+      }
+      return await adapters.commandWire.executeCommand(this.data.name, params);
+    };
+    return Object.assign(executeFunc, { params: this.data.params });
+  }
+  async executeLocally(params, adapters) {
+    if (!this.data.handler) {
+      throw new Error(`Command "${this.data.name}" has no handler`);
+    }
+    const context2 = this.buildCommandContext(adapters);
+    return await this.data.handler(context2, params);
+  }
+  buildCommandContext(adapters) {
+    const context2 = this.#fn.buildContext(adapters);
+    if (this.#fn.hasProtections && adapters.authAdapter) {
+      const decoded = adapters.authAdapter.getDecoded();
+      if (decoded) {
+        context2.$auth = {
+          params: decoded.params,
+          tokenName: decoded.tokenName
+        };
+      } else {
+        throw new Error(`Command "${this.data.name}" requires authentication but no valid token found`);
+      }
+    }
+    return context2;
+  }
+  toJsonSchema() {
+    const parametersSchema = this.data.params ? this.data.params.toJsonSchema?.() ?? {
+      type: "object",
+      properties: {}
+    } : { type: "object", properties: {} };
+    return {
+      type: "function",
+      name: this.data.name,
+      description: this.data.description ?? undefined,
+      parameters: parametersSchema,
+      strict: true
+    };
+  }
+}
+class ArcListener extends ArcContextElement {
+  data;
+  #fn;
+  unsubscribers = [];
+  constructor(data, fn) {
+    super(data.name);
+    this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: null,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: [],
+      handler: null,
+      description: data.description
+    });
+  }
+  description(description) {
+    const newFn = this.#fn.description(description);
+    return new ArcListener({ ...this.data, description }, newFn);
+  }
+  listenTo(events) {
+    return new ArcListener({ ...this.data, eventElements: events }, this.#fn);
+  }
+  query(elements) {
+    const newFn = this.#fn.query(elements);
+    return new ArcListener({ ...this.data, queryElements: elements }, newFn);
+  }
+  mutate(elements) {
+    const newFn = this.#fn.mutate(elements);
+    return new ArcListener({ ...this.data, mutationElements: elements }, newFn);
+  }
+  async() {
+    return new ArcListener({ ...this.data, isAsync: true }, this.#fn);
+  }
+  handle(handler) {
+    return new ArcListener({ ...this.data, handler }, this.#fn);
+  }
+  get eventElements() {
+    return this.data.eventElements || [];
+  }
+  get isAsync() {
+    return this.data.isAsync;
+  }
+  async init(environment, adapters) {
+    if (environment !== "server") {
+      return;
+    }
+    if (!this.data.handler) {
+      console.warn(`Listener "${this.data.name}" has no handler`);
+      return;
+    }
+    if (!adapters.eventPublisher) {
+      console.warn(`Listener "${this.data.name}" cannot subscribe: no eventPublisher adapter`);
+      return;
+    }
+    for (const eventElement of this.data.eventElements) {
+      const unsubscribe = adapters.eventPublisher.subscribe(eventElement.name, async (event2) => {
+        await this.handleEvent(event2, adapters);
+      });
+      this.unsubscribers.push(unsubscribe);
+    }
+  }
+  async handleEvent(event2, adapters) {
+    if (!this.data.handler)
+      return;
+    const context2 = this.#fn.buildContext(adapters);
+    if (adapters.authAdapter) {
+      const decoded = adapters.authAdapter.getDecoded();
+      if (decoded) {
+        context2.$auth = {
+          params: decoded.params,
+          tokenName: decoded.tokenName
+        };
+      }
+    }
+    if (this.data.isAsync) {
+      Promise.resolve(this.data.handler(context2, event2)).catch((error) => {
+        console.error(`Async listener "${this.data.name}" error:`, error);
+      });
+    } else {
+      await this.data.handler(context2, event2);
+    }
+  }
+  destroy() {
+    for (const unsubscribe of this.unsubscribers) {
+      unsubscribe();
+    }
+    this.unsubscribers = [];
+  }
+}
+class ArcRoute extends ArcContextElement {
+  data;
+  #fn;
+  constructor(data, fn) {
+    super(data.name);
+    this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: null,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: data.protections || [],
+      handler: null,
+      description: data.description
+    });
+  }
+  description(description) {
+    const newFn = this.#fn.description(description);
+    return new ArcRoute({ ...this.data, description }, newFn);
+  }
+  path(path) {
+    return new ArcRoute({ ...this.data, path }, this.#fn);
+  }
+  public() {
+    return new ArcRoute({ ...this.data, isPublic: true }, this.#fn);
+  }
+  query(elements) {
+    const newFn = this.#fn.query(elements);
+    return new ArcRoute({ ...this.data, queryElements: elements }, newFn);
+  }
+  mutate(elements) {
+    const newFn = this.#fn.mutate(elements);
+    return new ArcRoute({ ...this.data, mutationElements: elements }, newFn);
+  }
+  protectBy(token, check) {
+    const newFn = this.#fn.protectedBy(token, check);
+    const existingProtections = this.data.protections || [];
+    return new ArcRoute({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    }, newFn);
+  }
+  handle(handlers) {
+    return new ArcRoute({ ...this.data, handlers }, this.#fn);
+  }
+  get routePath() {
+    return this.data.path || `/${this.data.name}`;
+  }
+  get fullPath() {
+    return `/route${this.routePath}`;
+  }
+  get isPublic() {
+    return this.data.isPublic;
+  }
+  get hasProtections() {
+    return this.#fn.hasProtections;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  getHandler(method) {
+    return this.data.handlers?.[method];
+  }
+  matchesPath(pathname) {
+    const routePath = this.fullPath;
+    const routeParts = routePath.split("/").filter(Boolean);
+    const pathParts = pathname.split("/").filter(Boolean);
+    if (routeParts.length !== pathParts.length) {
+      return { matches: false, params: {} };
+    }
+    const params = {};
+    for (let i = 0;i < routeParts.length; i++) {
+      const routePart = routeParts[i];
+      const pathPart = pathParts[i];
+      if (routePart.startsWith(":")) {
+        const paramName = routePart.slice(1);
+        params[paramName] = pathPart;
+      } else if (routePart !== pathPart) {
+        return { matches: false, params: {} };
+      }
+    }
+    return { matches: true, params };
+  }
+  async verifyProtections(tokens) {
+    if (this.data.isPublic) {
+      return true;
+    }
+    return this.#fn.verifyProtections(tokens);
+  }
+  buildContext(adapters, authParams) {
+    const context2 = this.#fn.buildContext(adapters);
+    if (authParams) {
+      context2.$auth = authParams;
+    }
+    return context2;
+  }
+}
 class DataStorage {
   async commitChanges(changes) {
     await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-sqlite",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,7 +20,7 @@
     "test": "bun test"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.4.7"
+    "@arcote.tech/arc": "^0.5.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0"