@coasys/ad4m-connect 0.13.0-postmessage-ws-proxy.4 → 0.13.0-postmessage-ws-proxy.5

package/dist/index.js

@@ -203,6 +203,79 @@ PostMessageWebSocket.CLOSING = 2;
 PostMessageWebSocket.CLOSED = 3;
 PostMessageWebSocket.CONNECT_TIMEOUT_MS = 3e4;
 
+// src/PostMessageFetch.ts
+var _idCounter = 0;
+var PROXY_FETCH_TIMEOUT_MS = 6e4;
+function serialiseHeaders(headers) {
+  if (!headers)
+    return {};
+  if (headers instanceof Headers) {
+    const out = {};
+    headers.forEach((v2, k2) => {
+      out[k2] = v2;
+    });
+    return out;
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return __spreadValues({}, headers);
+}
+function makePostMessageFetch(targetOrigin) {
+  return function postMessageFetch(input, init) {
+    return __async(this, null, function* () {
+      var _a;
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      const method = (_a = init == null ? void 0 : init.method) != null ? _a : "GET";
+      const headers = serialiseHeaders(init == null ? void 0 : init.headers);
+      const id = String(++_idCounter);
+      let bodyBuffer = null;
+      if ((init == null ? void 0 : init.body) instanceof ArrayBuffer) {
+        const b2 = init.body;
+        bodyBuffer = b2.slice(0);
+      }
+      return new Promise((resolve, reject) => {
+        let timer = null;
+        const cleanup = () => {
+          window.removeEventListener("message", handler);
+          if (timer)
+            clearTimeout(timer);
+        };
+        const handler = (event) => {
+          if (event.source !== window.parent)
+            return;
+          if (event.origin !== targetOrigin)
+            return;
+          if (!event.data || event.data.id !== id)
+            return;
+          if (event.data.type === "AD4M_PROXY_HTTP_RESPONSE") {
+            cleanup();
+            const { status, statusText, body } = event.data;
+            resolve(new Response(body != null ? body : null, { status, statusText }));
+            return;
+          }
+          if (event.data.type === "AD4M_PROXY_HTTP_ERROR") {
+            cleanup();
+            reject(new TypeError(event.data.message || "Failed to fetch"));
+            return;
+          }
+        };
+        window.addEventListener("message", handler);
+        timer = setTimeout(() => {
+          cleanup();
+          reject(new TypeError(`AD4M proxy HTTP request timed out after ${PROXY_FETCH_TIMEOUT_MS}ms`));
+        }, PROXY_FETCH_TIMEOUT_MS);
+        const msg = { type: "AD4M_PROXY_HTTP_REQUEST", id, url, method, headers };
+        if (bodyBuffer) {
+          window.parent.postMessage(__spreadProps(__spreadValues({}, msg), { body: bodyBuffer }), targetOrigin, [bodyBuffer]);
+        } else {
+          window.parent.postMessage(__spreadProps(__spreadValues({}, msg), { body: null }), targetOrigin);
+        }
+      });
+    });
+  };
+}
+
 // ../core/lib/index.js
 var RpcError = class extends Error {
   constructor(status, body) {
@@ -215,12 +288,12 @@ var RpcError = class extends Error {
 var DEFAULT_TIMEOUT_MS = 3e4;
 var MAX_RECONNECT_DELAY_MS = 3e4;
 var INITIAL_RECONNECT_DELAY_MS = 500;
-var _idCounter = 0;
+var _idCounter2 = 0;
 function nextId() {
-  return String(++_idCounter);
+  return String(++_idCounter2);
 }
 var ApiClient = class {
-  constructor(baseUrl, token, webSocketImpl) {
+  constructor(baseUrl, token, webSocketImpl, fetchImpl) {
     this._ws = null;
     this._wsCallbacks = /* @__PURE__ */ new Set();
     this._pendingCalls = /* @__PURE__ */ new Map();
@@ -233,6 +306,7 @@ var ApiClient = class {
     this.baseUrl = baseUrl;
     this.token = token;
     this._webSocketImpl = webSocketImpl;
+    this._fetchImpl = fetchImpl;
   }
   getBaseUrl() {
     return this.baseUrl;
@@ -240,14 +314,17 @@ var ApiClient = class {
   getToken() {
     return this.token;
   }
+  doFetch(url, init) {
+    return this._fetchImpl ? this._fetchImpl(url, init) : fetch(url, init);
+  }
   setToken(token) {
     this.token = token;
   }
   _getWsUrl() {
     const wsBase = this.baseUrl.replace(/^http:\/\//, "ws://").replace(/^https:\/\//, "wss://");
     const tokenParam = this.token ? `token=${encodeURIComponent(this.token)}` : "";
-    const path = "/api/v1/ws";
-    return tokenParam ? `${wsBase}${path}?${tokenParam}` : `${wsBase}${path}`;
+    const path2 = "/api/v1/ws";
+    return tokenParam ? `${wsBase}${path2}?${tokenParam}` : `${wsBase}${path2}`;
   }
   _ensureWs() {
     if (this._ws && (this._ws.readyState === 1 || this._ws.readyState === 0)) {
@@ -672,9 +749,9 @@ var Literal = class {
     __classPrivateFieldSet$b(l5, _Literal_url, url, "f");
     return l5;
   }
-  static from(literal) {
+  static from(literal2) {
     const l5 = new Literal();
-    __classPrivateFieldSet$b(l5, _Literal_literal, literal, "f");
+    __classPrivateFieldSet$b(l5, _Literal_literal, literal2, "f");
     return l5;
   }
   toUrl() {
@@ -881,6 +958,32 @@ function buildSDNA(subjectName, obj, properties, allRelationsMeta) {
     name: subjectName
   };
 }
+function isNodeExpression(v2) {
+  if (typeof v2 !== "object" || v2 === null)
+    return false;
+  const obj = v2;
+  const type = obj.type;
+  switch (type) {
+    case "focus":
+      return typeof obj.type === "string";
+    case "literal":
+      return typeof obj.value === "string" || typeof obj.value === "number" || typeof obj.value === "boolean";
+    case "path":
+      return typeof obj.predicate === "string";
+    case "exists":
+      return isNodeExpression(obj.expr);
+    case "if":
+      return isNodeExpression(obj.cond) && isNodeExpression(obj.then) && (obj.else === void 0 || isNodeExpression(obj.else));
+    case "concat":
+      return Array.isArray(obj.args) && obj.args.every(isNodeExpression);
+    case "coalesce":
+      return Array.isArray(obj.args) && obj.args.every(isNodeExpression);
+    case "function":
+      return typeof obj.iri === "string" && Array.isArray(obj.args) && obj.args.every(isNodeExpression);
+    default:
+      return false;
+  }
+}
 function extractNamespace(uri) {
   const hashIndex = uri.lastIndexOf("#");
   if (hashIndex !== -1) {
@@ -1141,7 +1244,7 @@ var SHACLShape = class {
           target: `literal:${prop.writable}`
         });
       }
-      if (prop.resolveLanguage) {
+      if (prop.resolveLanguage != null) {
         links.push({
           source: propShapeId,
           predicate: "ad4m://resolveLanguage",
@@ -1232,6 +1335,13 @@ var SHACLShape = class {
           target: `literal:${prop.filter}`
         });
       }
+      if (prop.transform && typeof prop.transform === "object") {
+        links.push({
+          source: propShapeId,
+          predicate: "ad4m://transform",
+          target: `literal:string:${JSON.stringify(prop.transform)}`
+        });
+      }
     }
     return links;
   }
@@ -1414,6 +1524,19 @@ var SHACLShape = class {
           val = val.substring(8);
         prop.filter = val === "true";
       }
+      const transformLink = links.find((l5) => l5.source === propShapeId && l5.predicate === "ad4m://transform");
+      if (transformLink) {
+        const jsonStr = transformLink.target.replace(/^literal:\/\/string:|^literal:string:/, "");
+        try {
+          const parsed = JSON.parse(jsonStr);
+          if (!isNodeExpression(parsed)) {
+            throw new Error(`Invalid transform for property ${propShapeId}: payload is not a valid NodeExpression. Received: ${jsonStr}`);
+          }
+          prop.transform = parsed;
+        } catch (e7) {
+          throw new Error(`Failed to deserialize transform for property ${propShapeId}: ${e7 instanceof Error ? e7.message : String(e7)}. Payload: ${jsonStr}`);
+        }
+      }
       shape.addProperty(prop);
     }
     return shape;
@@ -1448,7 +1571,8 @@ var SHACLShape = class {
         target_class_name: p2.targetClassName,
         where_filter: p2.whereFilter,
         where_predicates: p2.wherePredicates,
-        filter: p2.filter
+        filter: p2.filter,
+        transform: p2.transform
       })),
       constructor_actions: this.constructor_actions,
       destructor_actions: this.destructor_actions
@@ -1457,6 +1581,9 @@ var SHACLShape = class {
   static fromJSON(json) {
     const shape = json.node_shape_uri ? new SHACLShape(json.node_shape_uri, json.target_class) : new SHACLShape(json.target_class);
     for (const p2 of json.properties || []) {
+      if (p2.transform && !isNodeExpression(p2.transform)) {
+        throw new Error(`Invalid transform for property ${p2.name}: payload is not a valid NodeExpression. Received: ${JSON.stringify(p2.transform)}`);
+      }
       shape.addProperty({
         path: p2.path,
         name: p2.name,
@@ -1482,7 +1609,8 @@ var SHACLShape = class {
         targetClassName: p2.target_class_name,
         whereFilter: p2.where_filter,
         wherePredicates: p2.where_predicates,
-        filter: p2.filter
+        filter: p2.filter,
+        transform: p2.transform
       });
     }
     if (json.constructor_actions) {
@@ -1570,12 +1698,15 @@ function buildSHACL(subjectName, target, properties, allRelationsMeta, conforman
     if (propMeta.writable !== void 0) {
       propShape.writable = propMeta.writable;
     }
-    if (propMeta.resolveLanguage) {
+    if (propMeta.resolveLanguage != null) {
       propShape.resolveLanguage = propMeta.resolveLanguage;
     }
     if (propMeta.getter) {
       propShape.getter = propMeta.getter;
     }
+    if (propMeta.transform) {
+      propShape.transform = propMeta.transform;
+    }
     if (propMeta.prologSetter) {
       console.warn(`[SHACL Generation] Custom Prolog setter for property '${propName}' in class '${subjectName}' is not yet supported. The property will be created without setter actions. Consider using standard writable properties or provide explicit SHACL JSON.`);
     } else if (propMeta.writable && propMeta.through) {
@@ -8948,7 +9079,7 @@ var AIClient = class {
     const baseUrl = __classPrivateFieldGet$2(this, _AIClient_apiClient, "f").getBaseUrl();
     const token = __classPrivateFieldGet$2(this, _AIClient_apiClient, "f").getToken();
     const bodyBuffer = typedAudio.buffer.slice(typedAudio.byteOffset, typedAudio.byteOffset + typedAudio.byteLength);
-    const response = await fetch(`${baseUrl}/api/v1/ai/transcription/feed`, {
+    const response = await __classPrivateFieldGet$2(this, _AIClient_apiClient, "f").doFetch(`${baseUrl}/api/v1/ai/transcription/feed`, {
       method: "POST",
       headers: {
         "Content-Type": "application/octet-stream",
@@ -8988,8 +9119,8 @@ function normalizeNamespaceString(namespace) {
     return "";
   if (namespace.includes("://")) {
     const [scheme, rest] = namespace.split("://");
-    const path = (rest || "").replace(/\/+$/, "");
-    return `${scheme}://${path}`;
+    const path2 = (rest || "").replace(/\/+$/, "");
+    return `${scheme}://${path2}`;
   } else {
     return namespace.replace(/\/+$/, "");
   }
@@ -9587,11 +9718,7 @@ var ModelQueryBuilder = class {
     const parseResults = (raw) => {
       return ctor.parseModelResult(this.perspective, raw, this.queryParams.include, this.queryParams.properties);
     };
-    const resolveAndReturn = async (instances) => {
-      await ctor.resolveNonLiteralProps(this.perspective, instances);
-      return instances;
-    };
-    const initialResults = await resolveAndReturn(parseResults(initialModelResult));
+    const initialResults = parseResults(initialModelResult);
     let lastResultFingerprint = null;
     const buildFingerprint = (results) => {
       if (results.length === 0)
@@ -9601,20 +9728,16 @@ var ModelQueryBuilder = class {
     lastResultFingerprint = buildFingerprint(initialResults);
     const unsubscribe = this.perspective.client.subscribeToQueryUpdates(subscriptionId, (rawResult) => {
       try {
-        const parsed = parseResults(rawResult);
-        console.debug(`[ModelQueryBuilder.subscribe] Update received for ${subscriptionId}: ${parsed.length} instances`);
-        resolveAndReturn(parsed).then((results) => {
-          const fp = buildFingerprint(results);
-          if (fp === lastResultFingerprint) {
-            console.debug(`[ModelQueryBuilder.subscribe] Fingerprint unchanged, skipping callback`);
-            return;
-          }
-          console.debug(`[ModelQueryBuilder.subscribe] Fingerprint changed, calling callback with ${results.length} results`);
-          lastResultFingerprint = fp;
-          callback(results);
-        }).catch((e7) => {
-          console.error("Model subscription update resolve error:", e7);
-        });
+        const results = parseResults(rawResult);
+        console.debug(`[ModelQueryBuilder.subscribe] Update received for ${subscriptionId}: ${results.length} instances`);
+        const fp = buildFingerprint(results);
+        if (fp === lastResultFingerprint) {
+          console.debug(`[ModelQueryBuilder.subscribe] Fingerprint unchanged, skipping callback`);
+          return;
+        }
+        console.debug(`[ModelQueryBuilder.subscribe] Fingerprint changed, calling callback with ${results.length} results`);
+        lastResultFingerprint = fp;
+        callback(results);
       } catch (e7) {
         console.error("Model subscription update parse error:", e7);
       }
@@ -9828,27 +9951,6 @@ function normalizeValue(value) {
   }
   return value;
 }
-function defaultFileDecode(resolved) {
-  if (resolved !== null && typeof resolved === "object" && "data_base64" in resolved) {
-    const fd = resolved;
-    let raw;
-    try {
-      raw = atob(fd.data_base64);
-    } catch {
-      return resolved;
-    }
-    const isJson = !fd.file_type || fd.file_type === "application/json";
-    if (isJson) {
-      try {
-        return JSON.parse(raw);
-      } catch {
-        return raw;
-      }
-    }
-    return raw;
-  }
-  return resolved;
-}
 function jsonToModelInstance(ModelClass, perspective, json, include, properties) {
   const instance = new ModelClass(perspective, json.id || json.baseExpression);
   if (properties) {
@@ -9882,19 +9984,6 @@ function jsonToModelInstance(ModelClass, perspective, json, include, properties)
     }
     instance[key] = value;
   }
-  try {
-    const propsMeta = getPropertiesMetadata(ModelClass);
-    for (const [propName, opts] of Object.entries(propsMeta)) {
-      const o6 = opts;
-      if (typeof o6.transform !== "function" || !(propName in json))
-        continue;
-      if (o6.resolveLanguage != null && o6.resolveLanguage !== "literal")
-        continue;
-      instance[propName] = o6.transform(instance[propName]);
-    }
-  } catch (e7) {
-    console.debug("jsonToModelInstance: transform metadata unavailable:", e7);
-  }
   if (include) {
     const relMeta = getRelationsMetadata(ModelClass);
     for (const [relName, includeVal] of Object.entries(include)) {
@@ -9968,8 +10057,8 @@ var Ad4mModel = class {
         ...options.getter !== void 0 && { getter: options.getter },
         ...options.prologSetter !== void 0 && { prologSetter: options.prologSetter },
         ...options.local !== void 0 && { local: options.local },
-        ...options.transform !== void 0 && { transform: options.transform },
-        ...options.flag !== void 0 && { flag: options.flag }
+        ...options.flag !== void 0 && { flag: options.flag },
+        ...options.transform !== void 0 && { transform: options.transform }
       };
     }
     const relationsMetadata = {};
@@ -10271,44 +10360,12 @@ var Ad4mModel = class {
       return [];
     return arr.map((json) => jsonToModelInstance(this, perspective, json, include, properties));
   }
-  static async resolveNonLiteralProps(perspective, instances) {
-    const propsMeta = getPropertiesMetadata(this);
-    const resolveProps = Object.entries(propsMeta).filter(([, opts]) => opts.resolveLanguage != null && opts.resolveLanguage !== "literal");
-    if (resolveProps.length === 0)
-      return;
-    await Promise.all(instances.map(async (inst) => {
-      for (const [propName, opts] of resolveProps) {
-        const val = inst[propName];
-        const transform = opts.transform;
-        const applyTransform = (resolved) => typeof transform === "function" ? transform(resolved) : defaultFileDecode(resolved);
-        if (typeof val === "string" && val && !val.startsWith("literal:")) {
-          try {
-            const expression = await perspective.getExpression(val);
-            if (expression) {
-              let resolved;
-              try {
-                resolved = JSON.parse(expression.data);
-              } catch {
-                resolved = expression.data;
-              }
-              inst[propName] = applyTransform(resolved);
-            }
-          } catch (e7) {
-            console.debug(`resolveNonLiteralProps: resolution failed for '${propName}':`, e7);
-          }
-        } else if (val !== null && val !== void 0 && typeof val === "object") {
-          inst[propName] = applyTransform(val);
-        }
-      }
-    }));
-  }
   static async executeModelQuery(perspective, query = {}, classNameOverride) {
     const { className, queryJson } = this.prepareModelQueryParams(query, classNameOverride);
     const result = await perspective.modelQuery(className, queryJson);
     const instances = result.instances.map((json) => {
       return jsonToModelInstance(this, perspective, json, query.include, query.properties);
     });
-    await this.resolveNonLiteralProps(perspective, instances);
     const snapshotRelations = query.include ? Object.fromEntries(Object.entries(query.include).filter(([k2]) => !k2.startsWith("$"))) : void 0;
     for (const inst of instances) {
       inst.takeSnapshot(snapshotRelations && Object.keys(snapshotRelations).length > 0 ? snapshotRelations : void 0);
@@ -10774,7 +10831,7 @@ var Ad4mClient = class {
     _Ad4mClient_aiClient.set(this, void 0);
     __classPrivateFieldSet$1(this, _Ad4mClient_baseUrl, baseUrl, "f");
     __classPrivateFieldSet$1(this, _Ad4mClient_token, token, "f");
-    __classPrivateFieldSet$1(this, _Ad4mClient_apiClient, new ApiClient(baseUrl, token, options?.webSocketImpl), "f");
+    __classPrivateFieldSet$1(this, _Ad4mClient_apiClient, new ApiClient(baseUrl, token, options?.webSocketImpl, options?.fetchImpl), "f");
     __classPrivateFieldSet$1(this, _Ad4mClient_agentClient, new AgentClient(baseUrl, token, subscribe, __classPrivateFieldGet$1(this, _Ad4mClient_apiClient, "f")), "f");
     __classPrivateFieldSet$1(this, _Ad4mClient_expressionClient, new ExpressionClient(baseUrl, token, __classPrivateFieldGet$1(this, _Ad4mClient_apiClient, "f")), "f");
     __classPrivateFieldSet$1(this, _Ad4mClient_languageClient, new LanguageClient(baseUrl, token, __classPrivateFieldGet$1(this, _Ad4mClient_apiClient, "f")), "f");
@@ -10852,6 +10909,44 @@ var _SmartLiteral_base;
 _SmartLiteral_perspective = /* @__PURE__ */ new WeakMap(), _SmartLiteral_base = /* @__PURE__ */ new WeakMap();
 var NeighbourhoodExpression = class extends ExpressionGeneric() {
 };
+function focus() {
+  return Object.freeze({ type: "focus" });
+}
+function literal(value) {
+  return Object.freeze({ type: "literal", value });
+}
+function path(predicate) {
+  return Object.freeze({ type: "path", predicate });
+}
+function exists(expr) {
+  return Object.freeze({ type: "exists", expr });
+}
+function ifExpr(cond) {
+  return {
+    then: (thenExpr) => ({
+      else: (elseExpr) => {
+        return Object.freeze({
+          type: "if",
+          cond,
+          then: thenExpr,
+          ...elseExpr !== void 0 && { else: elseExpr }
+        });
+      },
+      toExpression: () => Object.freeze({
+        type: "if",
+        cond,
+        then: thenExpr
+      })
+    })
+  };
+}
+function concat(...args) {
+  return Object.freeze({ type: "concat", args });
+}
+function coalesce(...args) {
+  return Object.freeze({ type: "coalesce", args });
+}
+var fileToDataUri = ifExpr(exists(path("file_storage://data_base64"))).then(concat(literal("data:"), coalesce(path("file_storage://file_type"), literal("image/png")), literal(";base64,"), path("file_storage://data_base64"))).else(focus());
 
 // ../node_modules/.pnpm/auto-bind@5.0.1/node_modules/auto-bind/index.js
 var getAllProperties = (object) => {
@@ -11230,12 +11325,13 @@ var Ad4mConnect = class extends EventTarget {
                 super(url, parentOrigin);
               }
             }
+            const fetchImpl = makePostMessageFetch(parentOrigin);
             this.notifyConnectionChange("connecting");
             this.ad4mClient = new Ad4mClient(
               "http://proxy",
               normalizedToken,
               false,
-              { webSocketImpl: WsImpl }
+              { webSocketImpl: WsImpl, fetchImpl }
             );
             this.notifyConnectionChange("connected");
             yield this.checkAuth();