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

package/dist/index.js

@@ -1,4 +1,4 @@
-// ../../../../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",
@@ -2826,6 +2826,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;
@@ -2863,6 +3004,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/dist/worker.js

@@ -1,4 +1,4 @@
-// ../../../../node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-bundler-friendly.mjs
+// ../../../../node_modules/.bun/@sqlite.org+sqlite-wasm@3.46.0-build2/node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-bundler-friendly.mjs
 var sqlite3InitModule = (() => {
   var _scriptDir = import.meta.url;
   return function(config) {
@@ -5893,22 +5893,22 @@ var sqlite3InitModule = (() => {
           SBF.__makeDebugFlags = function(deriveFrom = null) {
             if (deriveFrom && deriveFrom.__flags)
               deriveFrom = deriveFrom.__flags;
-            const f = function f(flags) {
+            const f = function f2(flags) {
               if (arguments.length === 0) {
-                return f.__flags;
+                return f2.__flags;
               }
               if (flags < 0) {
-                delete f.__flags.getter;
-                delete f.__flags.setter;
-                delete f.__flags.alloc;
-                delete f.__flags.dealloc;
+                delete f2.__flags.getter;
+                delete f2.__flags.setter;
+                delete f2.__flags.alloc;
+                delete f2.__flags.dealloc;
               } else {
-                f.__flags.getter = (1 & flags) !== 0;
-                f.__flags.setter = (2 & flags) !== 0;
-                f.__flags.alloc = (4 & flags) !== 0;
-                f.__flags.dealloc = (8 & flags) !== 0;
+                f2.__flags.getter = (1 & flags) !== 0;
+                f2.__flags.setter = (2 & flags) !== 0;
+                f2.__flags.alloc = (4 & flags) !== 0;
+                f2.__flags.dealloc = (8 & flags) !== 0;
               }
-              return f._flags;
+              return f2._flags;
             };
             Object.defineProperty(f, "__flags", {
               iterable: false,
@@ -6306,7 +6306,7 @@ var sqlite3InitModule = (() => {
           }
           Object.defineProperty(ctor.prototype, key, prop);
         };
-        const StructBinder = function StructBinder(structName, structInfo) {
+        const StructBinder = function StructBinder2(structName, structInfo) {
           if (arguments.length === 1) {
             structInfo = structName;
             structName = structInfo.name;
@@ -6340,17 +6340,17 @@ var sqlite3InitModule = (() => {
           else if (structInfo.sizeof < lastMember.offset + lastMember.sizeof) {
             toss("Invalid struct config:", structName, "max member offset (" + lastMember.offset + ") ", "extends past end of struct (sizeof=" + structInfo.sizeof + ").");
           }
-          const debugFlags = rop(SBF.__makeDebugFlags(StructBinder.debugFlags));
-          const StructCtor = function StructCtor(externalMemory) {
-            if (!(this instanceof StructCtor)) {
+          const debugFlags = rop(SBF.__makeDebugFlags(StructBinder2.debugFlags));
+          const StructCtor = function StructCtor2(externalMemory) {
+            if (!(this instanceof StructCtor2)) {
               toss("The", structName, "constructor may only be called via 'new'.");
             } else if (arguments.length) {
               if (externalMemory !== (externalMemory | 0) || externalMemory <= 0) {
                 toss("Invalid pointer value for", structName, "constructor.");
               }
-              __allocStruct(StructCtor, this, externalMemory);
+              __allocStruct(StructCtor2, this, externalMemory);
             } else {
-              __allocStruct(StructCtor, this);
+              __allocStruct(StructCtor2, this);
             }
           };
           Object.defineProperties(StructCtor, {
@@ -8328,7 +8328,7 @@ var sqlite3InitModule = (() => {
             return arg.returnVal();
           },
           createFunction: function f(name, xFunc, opt) {
-            const isFunc = (f) => f instanceof Function;
+            const isFunc = (f2) => f2 instanceof Function;
             switch (arguments.length) {
               case 1:
                 opt = name;
@@ -8520,8 +8520,8 @@ var sqlite3InitModule = (() => {
             f._ = {
               string: function(stmt2, ndx2, val2, asBlob) {
                 const [pStr, n] = wasm.allocCString(val2, true);
-                const f = asBlob ? capi.sqlite3_bind_blob : capi.sqlite3_bind_text;
-                return f(stmt2.pointer, ndx2, pStr, n, capi.SQLITE_WASM_DEALLOC);
+                const f2 = asBlob ? capi.sqlite3_bind_blob : capi.sqlite3_bind_text;
+                return f2(stmt2.pointer, ndx2, pStr, n, capi.SQLITE_WASM_DEALLOC);
               }
             };
           }
@@ -9841,7 +9841,7 @@ Total of`, n, "op(s) for", t, "ms (incl. " + w + " ms of waiting on the async si
             };
             opfsUtil.randomFilename = randomFilename;
             opfsUtil.treeList = async function() {
-              const doDir = async function callee(dirHandle, tgt) {
+              const doDir = async function callee2(dirHandle, tgt) {
                 tgt.name = dirHandle.name;
                 tgt.dirs = [];
                 tgt.files = [];
@@ -9849,7 +9849,7 @@ Total of`, n, "op(s) for", t, "ms (incl. " + w + " ms of waiting on the async si
                   if (handle.kind === "directory") {
                     const subDir = Object.create(null);
                     tgt.dirs.push(subDir);
-                    await callee(handle, subDir);
+                    await callee2(handle, subDir);
                   } else {
                     tgt.files.push(handle.name);
                   }
@@ -9888,12 +9888,12 @@ Total of`, n, "op(s) for", t, "ms (incl. " + w + " ms of waiting on the async si
                 opt = { callback: opt };
               }
               opt = Object.assign(defaultOpt, opt || {});
-              const doDir = async function callee(dirHandle, depth) {
+              const doDir = async function callee2(dirHandle, depth) {
                 for await (const handle of dirHandle.values()) {
                   if (opt.callback(handle, dirHandle, depth) === false)
                     return false;
                   else if (opt.recursive && handle.kind === "directory") {
-                    if (await callee(handle, depth + 1) === false)
+                    if (await callee2(handle, depth + 1) === false)
                       break;
                   }
                 }
@@ -10913,7 +10913,7 @@ var toExportForESM = function() {
 sqlite3InitModule = toExportForESM;
 var sqlite3_bundler_friendly_default = sqlite3InitModule;
 
-// ../../../../node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-worker1-promiser.mjs
+// ../../../../node_modules/.bun/@sqlite.org+sqlite-wasm@3.46.0-build2/node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-worker1-promiser.mjs
 globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfig) {
   if (arguments.length === 1 && typeof arguments[0] === "function") {
     const f = config;
@@ -11067,7 +11067,7 @@ sqlite3Worker1Promiser.v2 = function(config) {
 });
 var sqlite3_worker1_promiser_default = sqlite3Worker1Promiser.v2;
 
-// ../../../../node_modules/@sqlite.org/sqlite-wasm/index.mjs
+// ../../../../node_modules/.bun/@sqlite.org+sqlite-wasm@3.46.0-build2/node_modules/@sqlite.org/sqlite-wasm/index.mjs
 var sqlite3Worker1Promiser2 = self.sqlite3Worker1Promiser;
 var sqlite_wasm_default = sqlite3_bundler_friendly_default;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-sqlite-wasm",
-  "version": "0.4.9",
+  "version": "0.5.1",
   "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.4.9",
+    "@arcote.tech/arc": "^0.5.1",
     "@sqlite.org/sqlite-wasm": "^3.46.0-build1"
   },
   "devDependencies": {