@distrohelena/canton-typescript-sdk 0.1.36 → 0.1.37

package/dist/query/grpc/grpc-contract-query-client.d.ts

@@ -1,33 +0,0 @@
-import { StateServiceClient } from "../../services/state/state-service-client.js";
-import { QueryCacheStore } from "../cache/query-cache-store.js";
-import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractRow, JsonProjectionResult } from "../model-types.js";
-import { QueryClient } from "../query-client.js";
-import { QuerySource } from "../query-source.js";
-type ActiveContractsReader = Pick<StateServiceClient, "getActiveContractsPageAsync">;
-export declare class GrpcContractQueryClient implements QueryClient {
-    private readonly stateService;
-    private readonly cache;
-    private readonly cacheTtlMs;
-    private readonly cacheScope;
-    readonly source = QuerySource.grpc;
-    readonly contracts: {
-        findMany: <TArgs extends ContractFindManyArgs>(args?: TArgs) => Promise<readonly (ContractRow & import("../model-types.js").ContractRelationRow & JsonProjectionResult<TArgs>)[]>;
-        findUnique: <TArgs extends ContractFindUniqueArgs>(args: TArgs) => Promise<(ContractRow & import("../model-types.js").ContractRelationRow & JsonProjectionResult<TArgs>) | undefined>;
-        count: (args?: ContractCountArgs) => Promise<number>;
-        aggregate: () => Promise<never>;
-        groupBy: () => Promise<never>;
-    };
-    readonly contractTypes: QueryClient["contractTypes"];
-    readonly events: QueryClient["events"];
-    readonly exercises: QueryClient["exercises"];
-    readonly exerciseTypes: QueryClient["exerciseTypes"];
-    readonly packages: QueryClient["packages"];
-    readonly transactions: QueryClient["transactions"];
-    readonly watermark: QueryClient["watermark"];
-    constructor(stateService: ActiveContractsReader, cache: QueryCacheStore | undefined, cacheTtlMs: number | undefined, cacheScope: string);
-    $queryRaw<TRow>(_sql: string, _values?: readonly unknown[]): Promise<readonly TRow[]>;
-    private findManyAsync;
-    private unsupported;
-    private readSnapshotAsync;
-}
-export {};

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

@@ -1,174 +0,0 @@
-import { mapGrpcQueryContractsRequest } from "../../transports/grpc/mappers/contracts-mapper.js";
-import { QueryCapabilityError } from "../errors/query-capability-error.js";
-import { QuerySource } from "../query-source.js";
-export class GrpcContractQueryClient {
-    stateService;
-    cache;
-    cacheTtlMs;
-    cacheScope;
-    source = QuerySource.grpc;
-    contracts = {
-        findMany: (args = {}) => this.findManyAsync(args).then((rows) => rows),
-        findUnique: (args) => {
-            if (args.select !== undefined || args.include !== undefined) {
-                return Promise.reject(new QueryCapabilityError(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 QueryCapabilityError(QuerySource.grpc, "contracts.aggregate");
-        },
-        groupBy: async () => {
-            throw new QueryCapabilityError(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 QueryCapabilityError(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 QueryCapabilityError(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 QueryCapabilityError(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 QueryCapabilityError(QuerySource.grpc, `${operation}.findMany`);
-            },
-            findUnique: async () => {
-                throw new QueryCapabilityError(QuerySource.grpc, `${operation}.findUnique`);
-            },
-            count: async () => {
-                throw new QueryCapabilityError(QuerySource.grpc, `${operation}.count`);
-            },
-            aggregate: async () => {
-                throw new QueryCapabilityError(QuerySource.grpc, `${operation}.aggregate`);
-            },
-            groupBy: async () => {
-                throw new QueryCapabilityError(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(mapGrpcQueryContractsRequest(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;
-    }
-}
-function hasUnsupportedFilter(where) {
-    if (where === undefined) {
-        return false;
-    }
-    else 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;
-    }
-    else 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);
-    }
-    else if (filter.lt !== undefined) {
-        return value < String(filter.lt);
-    }
-    else if (filter.lte !== undefined) {
-        return value <= String(filter.lte);
-    }
-    else if (filter.gt !== undefined) {
-        return value > String(filter.gt);
-    }
-    return value >= String(filter.gte);
-}