@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

package/dist/cjs/query/cache/memory-query-cache.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryQueryCache = void 0;
+class MemoryQueryCache {
+    now;
+    entries = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    async getAsync(key) {
+        const entry = this.entries.get(key);
+        if (entry === undefined) {
+            return undefined;
+        }
+        else if (entry.expiresAt <= this.now()) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async setAsync(key, value, ttlMs) {
+        this.entries.set(key, { expiresAt: this.now() + ttlMs, value });
+    }
+    async deleteAsync(key) {
+        this.entries.delete(key);
+    }
+}
+exports.MemoryQueryCache = MemoryQueryCache;

package/dist/cjs/query/cache/query-cache-store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/query/canton-manager-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/query/canton-manager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CantonManager = void 0;
+const canton_client_js_1 = require("../client/canton-client.js");
+const transport_kind_js_1 = require("../core/types/transport-kind.js");
+const validation_error_js_1 = require("../core/errors/validation-error.js");
+const grpc_contract_query_client_js_1 = require("./grpc/grpc-contract-query-client.js");
+const pqs_pool_js_1 = require("./pqs/pqs-pool.js");
+const pqs_query_client_js_1 = require("./pqs/pqs-query-client.js");
+const pqs_schema_profile_js_1 = require("./pqs/pqs-schema-profile.js");
+const query_source_js_1 = require("./query-source.js");
+class CantonManager {
+    grpc;
+    query;
+    pqsPool;
+    disposed = false;
+    constructor(options) {
+        if (options.grpc.transportKind !== transport_kind_js_1.TransportKind.grpc) {
+            throw new validation_error_js_1.ValidationError("CantonManager requires grpc transport for writes.");
+        }
+        else if (options.querySource === query_source_js_1.QuerySource.grpc && options.pqs !== undefined) {
+            throw new validation_error_js_1.ValidationError("PQS options require QuerySource.pqs.");
+        }
+        else if (options.querySource === query_source_js_1.QuerySource.pqs && options.pqs === undefined) {
+            throw new validation_error_js_1.ValidationError("QuerySource.pqs requires PQS options.");
+        }
+        this.grpc = new canton_client_js_1.CantonClient(options.grpc);
+        if (options.querySource === query_source_js_1.QuerySource.pqs) {
+            this.pqsPool = pqs_pool_js_1.PqsPool.create(options.pqs.connectionString);
+            const profile = new pqs_schema_profile_js_1.PqsSchemaProfileV1(options.pqs.schema);
+            this.query = new pqs_query_client_js_1.PqsQueryClient(this.pqsPool.pool, profile, (0, pqs_schema_profile_js_1.validatePqsSchemaAsync)(this.pqsPool.pool, profile));
+        }
+        else {
+            this.query = new grpc_contract_query_client_js_1.GrpcContractQueryClient(this.grpc.stateService, options.cache?.store, options.cache?.ttlMs, options.grpc.ledgerEndpoint ?? "ledger");
+        }
+    }
+    async disposeAsync() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        await this.pqsPool?.disposeAsync();
+        await this.grpc.disposeAsync();
+    }
+}
+exports.CantonManager = CantonManager;

package/dist/cjs/query/errors/pqs-query-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PqsQueryError = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class PqsQueryError extends canton_error_js_1.CantonError {
+    operation;
+    code;
+    constructor(init) {
+        super(`PQS query ${init.operation} failed${init.code === undefined ? "" : ` (${init.code})`}.`);
+        this.operation = init.operation;
+        this.code = init.code;
+        void init.cause;
+    }
+}
+exports.PqsQueryError = PqsQueryError;

package/dist/cjs/query/errors/pqs-schema-profile-error.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PqsSchemaProfileError = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class PqsSchemaProfileError extends canton_error_js_1.CantonError {
+}
+exports.PqsSchemaProfileError = PqsSchemaProfileError;

package/dist/cjs/query/errors/query-capability-error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryCapabilityError = void 0;
+const canton_error_js_1 = require("../../core/errors/canton-error.js");
+class QueryCapabilityError extends canton_error_js_1.CantonError {
+    source;
+    operation;
+    constructor(source, operation) {
+        super(`Query operation ${operation} is not supported by ${source}.`);
+        this.source = source;
+        this.operation = operation;
+    }
+}
+exports.QueryCapabilityError = QueryCapabilityError;

package/dist/cjs/query/grpc/grpc-contract-query-client.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcContractQueryClient = void 0;
+const get_active_contracts_page_request_js_1 = require("../../core/types/requests/get-active-contracts-page-request.js");
+const query_capability_error_js_1 = require("../errors/query-capability-error.js");
+const query_source_js_1 = require("../query-source.js");
+class GrpcContractQueryClient {
+    stateService;
+    cache;
+    cacheTtlMs;
+    cacheScope;
+    source = query_source_js_1.QuerySource.grpc;
+    contracts = {
+        findMany: (args = {}) => this.findManyAsync(args).then((rows) => rows),
+        findUnique: (args) => {
+            if (args.select !== undefined || args.include !== undefined) {
+                return Promise.reject(new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.findUnique"));
+            }
+            return this.findManyAsync({ where: { contractId: { equals: args.where.contractId } } }).then((rows) => rows[0]);
+        },
+        count: async (args = {}) => (await this.findManyAsync(args)).length,
+        aggregate: async () => {
+            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.aggregate");
+        },
+        groupBy: async () => {
+            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.groupBy");
+        },
+    };
+    contractTypes = this.unsupported("contractTypes");
+    events = this.unsupported("events");
+    exercises = this.unsupported("exercises");
+    exerciseTypes = this.unsupported("exerciseTypes");
+    packages = this.unsupported("packages");
+    transactions = this.unsupported("transactions");
+    watermark = this.unsupported("watermark");
+    constructor(stateService, cache, cacheTtlMs, cacheScope) {
+        this.stateService = stateService;
+        this.cache = cache;
+        this.cacheTtlMs = cacheTtlMs;
+        this.cacheScope = cacheScope;
+    }
+    async $queryRaw(_sql, _values = []) {
+        throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "query.$queryRaw");
+    }
+    async findManyAsync(args) {
+        if (hasUnsupportedFilter(args.where) ||
+            args.where?.active === false ||
+            args.where?.packageId !== undefined ||
+            args.where?.witnesses !== undefined ||
+            args.where?.contractId?.in !== undefined ||
+            args.where?.contractId?.is !== undefined ||
+            args.where?.contractId?.isNot !== undefined ||
+            args.where?.templateId !== undefined) {
+            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.findMany");
+        }
+        const findArgs = args;
+        if (findArgs.select !== undefined || findArgs.include !== undefined || findArgs.orderBy !== undefined || findArgs.skip !== undefined || findArgs.take !== undefined) {
+            throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, "contracts.findMany");
+        }
+        const snapshot = await this.readSnapshotAsync(args.parties);
+        let rows = snapshot.filter((row) => args.where?.contractId?.equals === undefined
+            ? true
+            : row.contractId === args.where.contractId.equals);
+        if (args.where?.payload !== undefined)
+            rows = rows.filter((row) => matchesPayload(row.payload, args.where.payload));
+        return rows;
+    }
+    unsupported(operation) {
+        return {
+            findMany: async () => {
+                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.findMany`);
+            },
+            findUnique: async () => {
+                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.findUnique`);
+            },
+            count: async () => {
+                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.count`);
+            },
+            aggregate: async () => {
+                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.aggregate`);
+            },
+            groupBy: async () => {
+                throw new query_capability_error_js_1.QueryCapabilityError(query_source_js_1.QuerySource.grpc, `${operation}.groupBy`);
+            },
+        };
+    }
+    async readSnapshotAsync(parties) {
+        const key = `${this.cacheScope}:${parties?.join(",") ?? "*"}`;
+        const cached = this.cache === undefined ? undefined : await this.cache.getAsync(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const rows = [];
+        let pageToken;
+        let activeAtOffset;
+        do {
+            const response = await this.stateService.getActiveContractsPageAsync(new get_active_contracts_page_request_js_1.GetActiveContractsPageRequest(parties === undefined
+                ? { allParties: true, activeAtOffset, pageToken }
+                : { parties, activeAtOffset, pageToken }));
+            activeAtOffset ??= response.activeAtOffset;
+            pageToken = response.nextPageToken;
+            rows.push(...response.activeContracts.map((response) => mapGrpcContract(response.contractEntry.oneofKind === "activeContract"
+                ? response.contractEntry.activeContract
+                : response)));
+        } while (pageToken !== undefined && pageToken.length > 0);
+        if (this.cache !== undefined && this.cacheTtlMs !== undefined) {
+            await this.cache.setAsync(key, rows, this.cacheTtlMs);
+        }
+        return rows;
+    }
+}
+exports.GrpcContractQueryClient = GrpcContractQueryClient;
+function hasUnsupportedFilter(where) {
+    if (where === undefined)
+        return false;
+    if ("and" in where || "or" in where || "not" in where || "createdEventOffset" in where || "createdAt" in where || "archivedEventOffset" in where || "archivedAt" in where)
+        return true;
+    for (const field of ["contractId", "templateId"]) {
+        const filter = where[field];
+        if (filter !== undefined && Object.keys(filter).some((key) => key !== "equals"))
+            return true;
+    }
+    return false;
+}
+function mapGrpcContract(value) {
+    const row = value;
+    const template = row.templateId;
+    return {
+        contractId: row.contractId ?? "",
+        templateId: { packageId: template?.packageId ?? "", moduleName: template?.moduleName ?? "", entityName: template?.entityName ?? "" },
+        packageId: null,
+        payload: row.payload,
+        witnesses: [],
+        createdEventOffset: "",
+        createdAt: null,
+        archivedEventOffset: null,
+        archivedAt: null,
+        active: true,
+    };
+}
+function matchesPayload(value, filter) {
+    const match = filter.match;
+    if (match === undefined)
+        return false;
+    const visit = (current, node) => Object.entries(node).every(([key, child]) => {
+        const next = current !== null && typeof current === "object" ? current[key] : undefined;
+        const predicate = child;
+        if (Object.keys(predicate).some((name) => ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].includes(name)))
+            return compare(String(next ?? ""), predicate);
+        return visit(next, predicate);
+    });
+    return visit(value, match);
+}
+function compare(value, filter) { if (filter.equals !== undefined)
+    return value === filter.equals; if (filter.like !== undefined || filter.ilike !== undefined) {
+    const pattern = String(filter.like ?? filter.ilike).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replaceAll("%", ".*").replaceAll("_", ".");
+    return new RegExp(`^${pattern}$`, filter.ilike === undefined ? "" : "i").test(value);
+} if (filter.lt !== undefined)
+    return value < String(filter.lt); if (filter.lte !== undefined)
+    return value <= String(filter.lte); if (filter.gt !== undefined)
+    return value > String(filter.gt); return value >= String(filter.gte); }

package/dist/cjs/query/model-types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertQueryPageArgs = assertQueryPageArgs;
+exports.assertQueryOrderBy = assertQueryOrderBy;
+function assertQueryPageArgs(args) {
+    assertPageValue(args.skip, "skip");
+    assertPageValue(args.take, "take");
+}
+function assertQueryOrderBy(orderBy) {
+    if (orderBy.length === 0 || orderBy.some((entry) => Object.keys(entry).length !== 1)) {
+        throw new Error("orderBy must be a non-empty list of one-field entries");
+    }
+}
+function assertPageValue(value, name) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+        throw new Error(`${name} must be a non-negative integer`);
+    }
+}

package/dist/cjs/query/pqs/pqs-pool.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PqsPool = void 0;
+const pg_1 = require("pg");
+class PqsPool {
+    pool;
+    disposed = false;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    static create(connectionString) {
+        return new PqsPool(new pg_1.Pool({ connectionString }));
+    }
+    async disposeAsync() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        await this.pool.end();
+    }
+}
+exports.PqsPool = PqsPool;