@ariestools/aries-datalake-client 0.1.19 → 0.1.21

package/dist/node/index.mjs

@@ -1,3 +1,252 @@
+// src/CompositePayloadsClient.ts
+var CompositePayloadsWriteError = class extends Error {
+  result;
+  constructor(result) {
+    super("Required datalake writes did not complete");
+    this.name = "CompositePayloadsWriteError";
+    this.result = result;
+  }
+};
+var CompositePayloadsReadError = class extends Error {
+  result;
+  constructor(result) {
+    super("Datalake read could not be verified");
+    this.name = "CompositePayloadsReadError";
+    this.result = result;
+  }
+};
+var CompositePayloadsClient = class {
+  identify;
+  targets;
+  constructor(options) {
+    if (typeof options.identify !== "function") throw new TypeError("Canonical payload identity is required");
+    if (options.targets.length === 0) throw new TypeError("At least one datalake target is required");
+    const names = /* @__PURE__ */ new Set();
+    this.targets = options.targets.map((target) => {
+      if (!/^[a-z0-9][a-z0-9._-]{0,63}$/i.test(target.name) || names.has(target.name)) {
+        throw new TypeError("Datalake target names must be unique non-secret identifiers");
+      }
+      names.add(target.name);
+      return { ...target, policy: snapshotPolicy(target.policy) };
+    });
+    this.identify = options.identify;
+  }
+  /** Missing hashes fall through in target order. Provider errors and corruption fail explicitly. */
+  async get(hashes) {
+    return (await this.getWithReceipts(hashes)).payloads;
+  }
+  async getMany(hashes) {
+    return await this.get(hashes);
+  }
+  async getWithReceipts(hashes) {
+    const requested = [...new Set(hashes)];
+    if (requested.some((hash) => typeof hash !== "string" || hash.length === 0)) throw new TypeError("Hashes must be non-empty strings");
+    const found = /* @__PURE__ */ new Map();
+    const result = {
+      payloads: [],
+      receipts: [],
+      sources: {}
+    };
+    for (const target of this.targets) {
+      const remaining = requested.filter((hash) => !found.has(hash));
+      if (remaining.length === 0) break;
+      const receipt = {
+        target: target.name,
+        requested: remaining,
+        found: []
+      };
+      result.receipts.push(receipt);
+      let response;
+      try {
+        response = await target.client.getMany([...remaining]);
+      } catch {
+        receipt.error = "provider_error";
+        throw new CompositePayloadsReadError(result);
+      }
+      try {
+        const verified = await this.verify(response, new Set(remaining));
+        for (const payload of verified.values()) {
+          found.set(payload._hash, payload);
+          result.sources[payload._hash] = target.name;
+          receipt.found.push(payload._hash);
+        }
+        result.payloads = requested.flatMap((hash) => found.has(hash) ? [found.get(hash)] : []);
+      } catch {
+        receipt.error = "invalid_response";
+        throw new CompositePayloadsReadError(result);
+      }
+    }
+    return result;
+  }
+  /** Payload-array acknowledgment suitable for consumers of insert/get method contracts. */
+  async insert(payloads) {
+    return (await this.insertWithReceipts(payloads)).acknowledged;
+  }
+  async insertWithReceipts(payloads) {
+    const snapshots = payloads.map(snapshotPayload);
+    const prepared = [];
+    const seen = /* @__PURE__ */ new Set();
+    const encoder = new TextEncoder();
+    for (const payload of snapshots) {
+      const { hash } = await this.identify(payload);
+      requireHash(hash);
+      if (!seen.has(hash)) {
+        prepared.push({
+          payload,
+          hash,
+          bytes: encoder.encode(JSON.stringify(payload)).byteLength
+        });
+        seen.add(hash);
+      }
+    }
+    const writes = this.targets.map((target) => prepareWrite(target, prepared));
+    const outcomes = await Promise.all(writes.map((write) => this.writeTarget(write)));
+    const acknowledged = /* @__PURE__ */ new Map();
+    for (const outcome of outcomes) {
+      for (const payload of outcome.acknowledged) acknowledged.set(payload._hash, payload);
+    }
+    const result = {
+      acknowledged: prepared.flatMap(({ hash }) => acknowledged.has(hash) ? [acknowledged.get(hash)] : []),
+      receipts: writes.map((write) => write.receipt)
+    };
+    if (result.receipts.some((receipt) => receipt.status === "failed")) throw new CompositePayloadsWriteError(result);
+    return result;
+  }
+  async verify(payloads, expected) {
+    if (!Array.isArray(payloads)) throw new TypeError("Expected payload array");
+    const snapshots = payloads.map((payload) => {
+      if (typeof payload?._sequence !== "string" || payload._sequence.length === 0) throw new TypeError("Missing storage sequence");
+      return {
+        ...snapshotPayload(payload),
+        _hash: payload._hash,
+        _dataHash: payload._dataHash,
+        _sequence: payload._sequence
+      };
+    });
+    const verified = /* @__PURE__ */ new Map();
+    for (const payload of snapshots) {
+      const identity = await this.identify(snapshotPayload(payload));
+      if (identity.hash !== payload._hash || identity.dataHash !== payload._dataHash || !expected.has(identity.hash)) {
+        throw new TypeError("Unexpected payload identity");
+      }
+      verified.set(identity.hash, payload);
+    }
+    return verified;
+  }
+  async writeTarget({
+    target,
+    payloads,
+    receipt
+  }) {
+    const result = { acknowledged: [], receipts: [receipt] };
+    if (payloads.length === 0) return result;
+    let response;
+    try {
+      response = await target.client.insert(payloads.map((item) => snapshotPayload(item.payload)));
+    } catch {
+      receipt.status = "failed";
+      receipt.error = "provider_error";
+      return result;
+    }
+    try {
+      await this.verify(response.inserted, new Set(receipt.eligible));
+      if (!Array.isArray(response.summary.rejected) || response.summary.rejected.some((hash) => !receipt.eligible.includes(hash))) {
+        throw new TypeError("Unexpected rejected hashes");
+      }
+      receipt.rejected = [...new Set(response.summary.rejected)];
+    } catch {
+      receipt.status = "failed";
+      receipt.error = "invalid_response";
+      return result;
+    }
+    let readback;
+    try {
+      readback = await target.client.getMany([...receipt.eligible]);
+    } catch {
+      receipt.status = "failed";
+      receipt.error = "provider_error";
+      return result;
+    }
+    try {
+      const verified = await this.verify(readback, new Set(receipt.eligible));
+      result.acknowledged = receipt.eligible.flatMap((hash) => verified.has(hash) ? [verified.get(hash)] : []);
+      receipt.acknowledged = result.acknowledged.map((payload) => payload._hash);
+      if (receipt.rejected.length > 0 || verified.size !== receipt.eligible.length) {
+        receipt.status = "failed";
+        receipt.error = receipt.rejected.length > 0 ? "policy_rejected" : "incomplete_readback";
+      }
+    } catch {
+      receipt.status = "failed";
+      receipt.error = "invalid_response";
+    }
+    return result;
+  }
+};
+function snapshotPolicy(policy) {
+  if (!policy || policy.mode !== "all" && policy.mode !== "selected") throw new TypeError("Explicit datalake policy is required");
+  if (policy.mode === "selected" && (!Array.isArray(policy.allowedSchemas) || policy.maxPayloadBytes === void 0)) {
+    throw new TypeError("Selected datalakes require an allowlist and byte limit");
+  }
+  for (const schemas of [policy.allowedSchemas, policy.disallowedSchemas]) {
+    if (schemas !== void 0 && (!Array.isArray(schemas) || schemas.some((schema) => typeof schema !== "string" || schema.length === 0))) {
+      throw new TypeError("Schema lists must contain non-empty identifiers");
+    }
+  }
+  for (const limit of [policy.maxPayloadBytes, ...Object.values(policy.schemaMaxPayloadBytes ?? {})]) {
+    if (limit !== void 0 && (!Number.isSafeInteger(limit) || limit <= 0)) throw new RangeError("Payload byte limits must be positive safe integers");
+  }
+  return {
+    ...policy,
+    allowedSchemas: policy.allowedSchemas === void 0 ? void 0 : [...policy.allowedSchemas],
+    disallowedSchemas: policy.disallowedSchemas === void 0 ? void 0 : [...policy.disallowedSchemas],
+    schemaMaxPayloadBytes: { ...policy.schemaMaxPayloadBytes }
+  };
+}
+function prepareWrite(target, payloads) {
+  const selected = [];
+  const excluded = [];
+  for (const item of payloads) {
+    const reason = exclusionReason(target.policy, item);
+    if (reason) excluded.push({ hash: item.hash, reason });
+    else selected.push(item);
+  }
+  return {
+    target,
+    payloads: selected,
+    receipt: {
+      target: target.name,
+      policyRevision: target.policy.revision,
+      eligible: selected.map((item) => item.hash),
+      excluded,
+      acknowledged: [],
+      rejected: [],
+      status: selected.length > 0 ? "complete" : "excluded"
+    }
+  };
+}
+function exclusionReason(policy, item) {
+  const { schema } = item.payload;
+  if (policy.allowedSchemas !== void 0 && !policy.allowedSchemas.includes(schema) || policy.disallowedSchemas?.includes(schema)) return "schema";
+  const schemaLimit = policy.schemaMaxPayloadBytes && Object.hasOwn(policy.schemaMaxPayloadBytes, schema) ? policy.schemaMaxPayloadBytes[schema] : void 0;
+  const limit = Math.min(policy.maxPayloadBytes ?? Infinity, schemaLimit ?? Infinity);
+  if (item.bytes > limit) return "size";
+  if (policy.isValid && !policy.isValid(snapshotPayload(item.payload))) return "validation";
+  return void 0;
+}
+function snapshotPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload) || typeof payload.schema !== "string" || payload.schema.length === 0) {
+    throw new TypeError("Expected flat schema-bearing payloads");
+  }
+  const stripped = Object.fromEntries(Object.entries(payload).filter(([key]) => !key.startsWith("_")));
+  const serialized = JSON.stringify(stripped);
+  const copy = JSON.parse(serialized);
+  if (copy.schema !== payload.schema) throw new TypeError("Payload serialization changed its schema");
+  return copy;
+}
+function requireHash(hash) {
+  if (typeof hash !== "string" || hash.length === 0) throw new TypeError("Canonical payload identity returned an invalid hash");
+}
+
 // src/credentials.ts
 import {
   chmodSync,
@@ -110,7 +359,8 @@ var LocalDatalakeClient = class {
     if (store.datalakes.some((dl) => dl.name === request.name)) {
       throw new Error(`Datalake already exists: ${request.name}`);
     }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const nowDate = /* @__PURE__ */ new Date();
+    const now = nowDate.toISOString();
     const tier = request.config.tier;
     const descriptor = {
       id: generateId(),
@@ -157,10 +407,11 @@ var LocalDatalakeClient = class {
     const store = readStore();
     const datalake = requireDatalake(store, request.datalakeId);
     const existing = datalake.acl.findIndex((entry2) => entry2.principal === request.principal);
+    const grantedAtDate = /* @__PURE__ */ new Date();
     const entry = {
       principal: request.principal,
       role: request.role,
-      grantedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      grantedAt: grantedAtDate.toISOString(),
       grantedBy: LOCAL_OWNER_ID
     };
     if (existing === -1) {
@@ -186,11 +437,12 @@ var LocalDatalakeClient = class {
         exp: Math.floor(Date.now() / 1e3) + ttl
       })
     ).toString("base64url");
+    const expiresAtDate = new Date(Date.now() + ttl * 1e3);
     return {
       token: `local.${issued}`,
       datalakeId: datalake.id,
       role: request.role,
-      expiresAt: new Date(Date.now() + ttl * 1e3).toISOString(),
+      expiresAt: expiresAtDate.toISOString(),
       url: datalake.url ?? `http://localhost:8080/datalakes/${datalake.name}`
     };
   }
@@ -198,7 +450,8 @@ var LocalDatalakeClient = class {
     const store = readStore();
     const datalake = requireDatalake(store, request.datalakeId);
     datalake.acl = datalake.acl.filter((entry) => entry.principal !== request.principal);
-    datalake.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const updatedAtDate = /* @__PURE__ */ new Date();
+    datalake.updatedAt = updatedAtDate.toISOString();
     writeStore(store);
     return datalake;
   }
@@ -337,10 +590,11 @@ import {
 function setDefaultDatalake(name, id) {
   const home = getAriesHome();
   if (!existsSync3(home)) mkdirSync3(home, { recursive: true });
+  const setAtDate = /* @__PURE__ */ new Date();
   const payload = {
     name,
     id,
-    setAt: (/* @__PURE__ */ new Date()).toISOString()
+    setAt: setAtDate.toISOString()
   };
   writeFileSync3(getDefaultDatalakePath(), JSON.stringify(payload, void 0, 2), "utf8");
 }
@@ -362,11 +616,9 @@ function clearDefaultDatalake() {
 
 // src/PayloadsClient.ts
 import {
-  DATALAKE_API_VERSION,
   DATALAKE_HEADER_DUPLICATES,
   DATALAKE_HEADER_NEXT_CURSOR,
   DATALAKE_HEADER_REJECTED,
-  DatalakeApiError as DatalakeApiError2,
   datalakePlaneClearPath,
   datalakePlaneDeletePath,
   datalakePlaneGetManyPath,
@@ -375,6 +627,9 @@ import {
   datalakePlaneNextPath,
   datalakePlaneUsagePath
 } from "@ariestools/aries-datalake-core/browser";
+
+// src/payloadRequest.ts
+import { DATALAKE_API_VERSION, DatalakeApiError as DatalakeApiError2 } from "@ariestools/aries-datalake-core/browser";
 function extractRequestBase(urlWithPossiblePath) {
   try {
     const parsed = new URL(urlWithPossiblePath);
@@ -386,6 +641,24 @@ function extractRequestBase(urlWithPossiblePath) {
     return urlWithPossiblePath.replace(/\/$/, "");
   }
 }
+function parsePayloadResponse(response, text, method) {
+  const payload = text.length > 0 ? JSON.parse(text) : void 0;
+  if (!response.ok) {
+    const errorBody = isApiErrorBody2(payload) ? payload : {
+      code: "internal",
+      message: "Unexpected " + response.status + " response from " + method + " data plane"
+    };
+    throw new DatalakeApiError2(response.status, errorBody);
+  }
+  return payload;
+}
+function isApiErrorBody2(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const maybe = value;
+  return typeof maybe.code === "string" && typeof maybe.message === "string";
+}
+
+// src/PayloadsClient.ts
 var RestPayloadsClient = class {
   authToken;
   datalakeId;
@@ -469,20 +742,12 @@ var RestPayloadsClient = class {
     const response = await this.fetchImpl(`${this.requestBase}${path4}`, init);
     if (response.status === 204) return { data: void 0, headers: response.headers };
     const text = await response.text();
-    const payload = text.length > 0 ? JSON.parse(text) : void 0;
-    if (!response.ok) {
-      const errorBody = isApiErrorBody2(payload) ? payload : {
-        code: "internal",
-        message: `Unexpected ${response.status} response from ${method} data plane`
-      };
-      throw new DatalakeApiError2(response.status, errorBody);
-    }
-    return { data: payload, headers: response.headers };
+    return { data: parsePayloadResponse(response, text, method), headers: response.headers };
   }
 };
 function readInsertSummary(headers) {
   const duplicatesRaw = headers.get(DATALAKE_HEADER_DUPLICATES);
-  const duplicates = duplicatesRaw === null ? 0 : Number.parseInt(duplicatesRaw, 10);
+  const duplicates = duplicatesRaw === null ? 0 : Math.trunc(Number(duplicatesRaw));
   const rejectedRaw = headers.get(DATALAKE_HEADER_REJECTED);
   const rejected = rejectedRaw === null || rejectedRaw.length === 0 ? [] : rejectedRaw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
   return {
@@ -490,15 +755,92 @@ function readInsertSummary(headers) {
     rejected
   };
 }
-function isApiErrorBody2(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const maybe = value;
-  return typeof maybe.code === "string" && typeof maybe.message === "string";
+
+// src/RestPublicPayloadsReader.ts
+import { datalakePlaneGetManyPath as datalakePlaneGetManyPath2, datalakePlaneGetPath as datalakePlaneGetPath2 } from "@ariestools/aries-datalake-core/browser";
+import { readResponseText } from "@ariestools/sdk/fetch";
+var RestPublicPayloadsReader = class {
+  datalakeId;
+  fetchImpl;
+  requestBase;
+  constructor(options) {
+    this.requestBase = publicRequestBase(options.baseUrl);
+    this.datalakeId = options.datalakeId;
+    this.fetchImpl = options.fetchImpl;
+  }
+  async get(hash, options = {}) {
+    const payload = await this.request(datalakePlaneGetPath2(this.datalakeId, hash), options);
+    if (!isStoredPayload(payload)) throw new TypeError("Data plane returned an invalid stored payload");
+    return payload;
+  }
+  async getMany(hashes, options = {}) {
+    const policy = pinReadOptions(options);
+    const requested = [...hashes];
+    if (requested.length === 0) return [];
+    const payloads = await this.request(datalakePlaneGetManyPath2(this.datalakeId), policy, requested);
+    if (!Array.isArray(payloads) || !payloads.every(isStoredPayload)) {
+      throw new TypeError("Data plane returned an invalid stored-payload array");
+    }
+    return payloads;
+  }
+  async request(path4, options, hashes) {
+    const { maxResponseBytes, signal } = pinReadOptions(options);
+    const method = hashes === void 0 ? "GET" : "POST";
+    const headers = { accept: "application/json" };
+    const init = {
+      credentials: "omit",
+      headers,
+      method,
+      redirect: "error",
+      signal
+    };
+    if (hashes !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(hashes);
+    }
+    const fetchImpl = this.fetchImpl ?? globalThis.fetch;
+    const response = await fetchImpl(this.requestBase + path4, init);
+    const text = await readResponseText(response, { maxResponseBytes, signal });
+    return parsePayloadResponse(response, text, method);
+  }
+};
+function pinReadOptions(options) {
+  const { maxResponseBytes, signal } = options;
+  if (maxResponseBytes !== void 0 && (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)) {
+    throw new RangeError("maxResponseBytes must be a positive safe integer");
+  }
+  signal?.throwIfAborted();
+  return { maxResponseBytes, signal };
+}
+function publicRequestBase(baseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    throw new TypeError("baseUrl must be an absolute HTTP(S) URL");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new TypeError("baseUrl must be an absolute HTTP(S) URL");
+  }
+  if (parsed.username !== "" || parsed.password !== "") {
+    throw new TypeError("Public data-plane URLs must not contain credentials");
+  }
+  if (parsed.href.includes("#")) throw new TypeError("Public data-plane URLs must not contain fragments");
+  return extractRequestBase(baseUrl);
+}
+function isStoredPayload(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const payload = value;
+  return ["schema", "_hash", "_dataHash", "_sequence"].every((key) => Object.hasOwn(payload, key) && typeof payload[key] === "string");
 }
 export {
+  CompositePayloadsClient,
+  CompositePayloadsReadError,
+  CompositePayloadsWriteError,
   LocalDatalakeClient,
   RestDatalakeClient,
   RestPayloadsClient,
+  RestPublicPayloadsReader,
   clearCredentials,
   clearDefaultDatalake,
   createDatalakeClient,