@distrohelena/canton-typescript-sdk 0.1.5 → 0.1.7

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

@@ -0,0 +1,126 @@
+import { GetActiveContractsPageRequest } from "../../core/types/requests/get-active-contracts-page-request.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),
+        findUnique: (args) => {
+            if (args.select !== 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");
+        },
+    };
+    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.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);
+        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`);
+            },
+        };
+    }
+    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 GetActiveContractsPageRequest(parties === undefined
+                ? { allParties: true, activeAtOffset, pageToken }
+                : { parties, activeAtOffset, pageToken }));
+            activeAtOffset ??= response.activeAtOffset;
+            pageToken = response.nextPageToken;
+            rows.push(...response.contracts.map(mapGrpcContract));
+        } 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;
+    if ("and" in where || "or" in where || "not" in where || "payload" 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: undefined,
+        witnesses: [],
+        createdEventOffset: "",
+        createdAt: null,
+        archivedEventOffset: null,
+        archivedAt: null,
+        active: true,
+    };
+}

package/dist/query/model-types.d.ts

@@ -0,0 +1,258 @@
+export type QueryOrder = "asc" | "desc";
+export interface ScalarFilter<T> {
+    readonly equals?: T;
+    readonly in?: readonly T[];
+    readonly is?: null;
+    readonly isNot?: null;
+}
+export interface OrderedFilter<T> extends ScalarFilter<T> {
+    readonly lt?: T;
+    readonly lte?: T;
+    readonly gt?: T;
+    readonly gte?: T;
+}
+export interface StringFilter extends OrderedFilter<string> {
+    readonly like?: string;
+    readonly ilike?: string;
+}
+export interface ArrayMembershipFilter {
+    readonly has: string;
+}
+export type WhereExpression<TFields> = TFields & {
+    readonly and?: readonly WhereExpression<TFields>[];
+    readonly or?: readonly WhereExpression<TFields>[];
+    readonly not?: WhereExpression<TFields>;
+};
+export type RowWhere<TRow, TOrdered extends keyof TRow = never, TPattern extends keyof TRow = never> = WhereExpression<Partial<{
+    readonly [TField in keyof TRow]: TRow[TField] extends readonly string[] ? ScalarFilter<TRow[TField]> | ArrayMembershipFilter : TField extends TPattern ? StringFilter : TField extends TOrdered ? OrderedFilter<TRow[TField]> : ScalarFilter<TRow[TField]>;
+}>>;
+export type RowSelect<TRow> = Partial<Record<keyof TRow, boolean>>;
+export type RowOrderBy<TRow> = Partial<Record<keyof TRow, QueryOrder>>;
+export interface QueryPageArgs {
+    readonly skip?: number;
+    readonly take?: number;
+}
+export interface ContractRow {
+    readonly contractId: string;
+    readonly templateId: TemplateId;
+    readonly packageId: string | null;
+    readonly payload: unknown;
+    readonly witnesses: readonly string[];
+    readonly createdEventOffset: string;
+    readonly createdAt: Date | null;
+    readonly archivedEventOffset: string | null;
+    readonly archivedAt: Date | null;
+    readonly active: boolean;
+}
+export interface TemplateId {
+    readonly packageId: string;
+    readonly moduleName: string;
+    readonly entityName: string;
+}
+type PayloadValueFilter = {
+    readonly equals: string;
+    readonly lt?: never;
+    readonly lte?: never;
+    readonly gt?: never;
+    readonly gte?: never;
+    readonly like?: never;
+    readonly ilike?: never;
+} | {
+    readonly lt: string;
+    readonly equals?: never;
+    readonly lte?: never;
+    readonly gt?: never;
+    readonly gte?: never;
+    readonly like?: never;
+    readonly ilike?: never;
+} | {
+    readonly lte: string;
+    readonly equals?: never;
+    readonly lt?: never;
+    readonly gt?: never;
+    readonly gte?: never;
+    readonly like?: never;
+    readonly ilike?: never;
+} | {
+    readonly gt: string;
+    readonly equals?: never;
+    readonly lt?: never;
+    readonly lte?: never;
+    readonly gte?: never;
+    readonly like?: never;
+    readonly ilike?: never;
+} | {
+    readonly gte: string;
+    readonly equals?: never;
+    readonly lt?: never;
+    readonly lte?: never;
+    readonly gt?: never;
+    readonly like?: never;
+    readonly ilike?: never;
+} | {
+    readonly like: string;
+    readonly equals?: never;
+    readonly lt?: never;
+    readonly lte?: never;
+    readonly gt?: never;
+    readonly gte?: never;
+    readonly ilike?: never;
+} | {
+    readonly ilike: string;
+    readonly equals?: never;
+    readonly lt?: never;
+    readonly lte?: never;
+    readonly gt?: never;
+    readonly gte?: never;
+    readonly like?: never;
+};
+export type ContractPayloadFilter = {
+    readonly path: string;
+} & PayloadValueFilter;
+type ContractWhereFields = {
+    readonly contractId?: StringFilter;
+    readonly templateId?: Partial<{
+        readonly packageId: StringFilter;
+        readonly moduleName: StringFilter;
+        readonly entityName: StringFilter;
+    }>;
+    readonly packageId?: StringFilter;
+    readonly createdEventOffset?: OrderedFilter<string>;
+    readonly createdAt?: OrderedFilter<Date | null>;
+    readonly archivedEventOffset?: OrderedFilter<string | null>;
+    readonly archivedAt?: OrderedFilter<Date | null>;
+    readonly active?: boolean | ScalarFilter<boolean>;
+    readonly witnesses?: {
+        readonly has: string;
+    };
+    readonly payload?: ContractPayloadFilter;
+};
+export type ContractWhere = WhereExpression<ContractWhereFields>;
+export type ContractOrderField = "contractId" | "createdEventOffset" | "createdAt" | "archivedEventOffset" | "archivedAt";
+export type ContractOrderBy = Partial<Record<ContractOrderField, QueryOrder>>;
+export type ContractSelect = Partial<Record<keyof ContractRow, boolean>>;
+export interface ContractFindManyArgs extends QueryPageArgs {
+    readonly parties?: readonly string[];
+    readonly where?: ContractWhere;
+    readonly orderBy?: ContractOrderBy;
+    readonly select?: ContractSelect;
+}
+export interface ContractFindUniqueArgs {
+    readonly where: {
+        readonly contractId: string;
+    };
+    readonly select?: ContractSelect;
+}
+export interface ContractCountArgs {
+    readonly parties?: readonly string[];
+    readonly where?: ContractWhere;
+}
+export interface ContractTypeRow {
+    readonly pk: string;
+    readonly payloadType: string;
+    readonly aliases: readonly string[];
+    readonly packageName: string;
+    readonly moduleName: string;
+    readonly entityName: string;
+    readonly templateFqn: string;
+}
+export interface EventRow {
+    readonly pk: string;
+    readonly txIx: string;
+    readonly eventId: string;
+    readonly type: string;
+}
+export interface ExerciseRow {
+    readonly tpePk: string;
+    readonly contractTpePk: string;
+    readonly exerciseEventPk: string | null;
+    readonly exercisedAtIx: string | null;
+    readonly contractId: string;
+    readonly argument: unknown;
+    readonly result: unknown;
+    readonly redactionId: string | null;
+    readonly packagePk: string;
+    readonly controllers: readonly string[];
+    readonly lastDescendantNodeId: number;
+    readonly witnesses: readonly string[];
+}
+export interface ExerciseTypeRow {
+    readonly pk: string;
+    readonly choice: string;
+    readonly consuming: boolean;
+    readonly aliases: readonly string[];
+    readonly packageName: string;
+    readonly moduleName: string;
+    readonly entityName: string;
+    readonly templateFqn: string;
+    readonly choiceFqn: string;
+}
+export interface PackageRow {
+    readonly pk: string;
+    readonly name: string;
+    readonly version: string;
+    readonly id: string;
+}
+export interface TransactionRow {
+    readonly ix: string;
+    readonly offset: string;
+    readonly transactionId: string | null;
+    readonly effectiveAt: Date | null;
+    readonly workflowId: string | null;
+    readonly domainId: string | null;
+    readonly traceContext: unknown;
+    readonly externalTransactionHash: Uint8Array | null;
+    readonly paidTrafficCost: string | null;
+}
+export interface WatermarkRow {
+    readonly singleton: boolean;
+    readonly ix: string | null;
+    readonly offset: string | null;
+    readonly instanceId: string | null;
+}
+export type ContractTypeWhere = RowWhere<ContractTypeRow, "pk", "payloadType" | "packageName" | "moduleName" | "entityName" | "templateFqn">;
+export type ContractTypeSelect = RowSelect<ContractTypeRow>;
+export type ContractTypeOrderBy = RowOrderBy<ContractTypeRow>;
+export type ContractTypeUnique = {
+    readonly pk: string;
+};
+export type EventWhere = RowWhere<EventRow, "pk" | "txIx", "eventId" | "type">;
+export type EventSelect = RowSelect<EventRow>;
+export type EventOrderBy = RowOrderBy<EventRow>;
+export type EventUnique = {
+    readonly pk: string;
+};
+export type ExerciseWhere = RowWhere<ExerciseRow, "tpePk" | "contractTpePk" | "exerciseEventPk" | "exercisedAtIx" | "packagePk" | "lastDescendantNodeId", "contractId" | "redactionId">;
+export type ExerciseSelect = RowSelect<ExerciseRow>;
+export type ExerciseOrderBy = RowOrderBy<ExerciseRow>;
+export type ExerciseTypeWhere = RowWhere<ExerciseTypeRow, "pk", "choice" | "packageName" | "moduleName" | "entityName" | "templateFqn" | "choiceFqn">;
+export type ExerciseTypeSelect = RowSelect<ExerciseTypeRow>;
+export type ExerciseTypeOrderBy = RowOrderBy<ExerciseTypeRow>;
+export type ExerciseTypeUnique = {
+    readonly pk: string;
+};
+export type PackageWhere = RowWhere<PackageRow, "pk", "name" | "version" | "id">;
+export type PackageSelect = RowSelect<PackageRow>;
+export type PackageOrderBy = RowOrderBy<PackageRow>;
+export type PackageUnique = {
+    readonly pk: string;
+} | {
+    readonly id: string;
+};
+export type TransactionWhere = RowWhere<TransactionRow, "ix" | "offset" | "effectiveAt" | "paidTrafficCost", "transactionId" | "workflowId" | "domainId">;
+export type TransactionSelect = RowSelect<TransactionRow>;
+export type TransactionOrderBy = RowOrderBy<TransactionRow>;
+export type TransactionUnique = {
+    readonly ix: string;
+} | {
+    readonly offset: string;
+};
+export type WatermarkWhere = RowWhere<WatermarkRow, "ix" | "offset", "instanceId">;
+export type WatermarkSelect = RowSelect<WatermarkRow>;
+export type WatermarkOrderBy = RowOrderBy<WatermarkRow>;
+export type WatermarkUnique = {
+    readonly singleton: boolean;
+};
+export declare function assertQueryPageArgs(args: QueryPageArgs): void;
+export declare function assertQueryOrderBy(orderBy: Readonly<Record<string, QueryOrder>>): void;
+export {};

package/dist/query/model-types.js

@@ -0,0 +1,14 @@
+export function assertQueryPageArgs(args) {
+    assertPageValue(args.skip, "skip");
+    assertPageValue(args.take, "take");
+}
+export function assertQueryOrderBy(orderBy) {
+    if (Object.keys(orderBy).length !== 1) {
+        throw new Error("orderBy must specify exactly one field");
+    }
+}
+function assertPageValue(value, name) {
+    if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
+        throw new Error(`${name} must be a non-negative integer`);
+    }
+}

package/dist/query/pqs/pqs-pool.d.ts

@@ -0,0 +1,13 @@
+export interface PqsPoolLike {
+    query(text: string, values: readonly unknown[]): Promise<{
+        readonly rows: readonly Record<string, unknown>[];
+    }>;
+    end(): Promise<void>;
+}
+export declare class PqsPool {
+    readonly pool: PqsPoolLike;
+    private disposed;
+    constructor(pool: PqsPoolLike);
+    static create(connectionString: string): PqsPool;
+    disposeAsync(): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import { Pool } from "pg";
+export class PqsPool {
+    pool;
+    disposed = false;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    static create(connectionString) {
+        return new PqsPool(new Pool({ connectionString }));
+    }
+    async disposeAsync() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        await this.pool.end();
+    }
+}

package/dist/query/pqs/pqs-query-client.d.ts

@@ -0,0 +1,49 @@
+import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractRow } from "../model-types.js";
+import { QueryClient } from "../query-client.js";
+import { QuerySource } from "../query-source.js";
+import { PqsSchemaProfileV1 } from "./pqs-schema-profile.js";
+export interface PqsQueryExecutor {
+    query(text: string, values: readonly unknown[]): Promise<{
+        readonly rows: readonly Record<string, unknown>[];
+    }>;
+}
+export declare class PqsQueryClient implements QueryClient {
+    private readonly executor;
+    private readonly profile;
+    private readonly ready;
+    readonly source = QuerySource.pqs;
+    readonly contracts: {
+        findMany: (args?: ContractFindManyArgs) => Promise<readonly ContractRow[]>;
+        findUnique: (args: ContractFindUniqueArgs) => Promise<ContractRow>;
+        count: (args?: ContractCountArgs) => Promise<number>;
+        aggregate: (args: Parameters<QueryClient["contracts"]["aggregate"]>[0]) => Promise<{
+            readonly count?: number;
+            readonly min?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
+            readonly max?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
+            readonly sum?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
+        }>;
+    };
+    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(executor: PqsQueryExecutor, profile: PqsSchemaProfileV1, ready?: Promise<void>);
+    $queryRaw<TRow>(sql: string, values?: readonly unknown[]): Promise<readonly TRow[]>;
+    private createPhysicalDelegate;
+    private readPhysicalAsync;
+    private aggregatePhysicalAsync;
+    private compileWhere;
+    private selectedFields;
+    private compileOrderBy;
+    private assertUniqueWhere;
+    private assertNumericField;
+    private field;
+    private assertPage;
+    private mapPhysicalRow;
+    private findContractsAsync;
+    private aggregateContractsAsync;
+    private wrap;
+}