@distrohelena/canton-typescript-sdk 0.1.8 → 0.1.11

package/dist/core/types/daml-contract-id.d.ts

@@ -0,0 +1,5 @@
+/** Explicit DAML contract-id value, distinguished from ordinary text. */
+export declare class DamlContractId {
+    readonly value: string;
+    constructor(value: string);
+}

package/dist/core/types/daml-contract-id.js

@@ -0,0 +1,11 @@
+import { ValidationError } from "../errors/validation-error.js";
+/** Explicit DAML contract-id value, distinguished from ordinary text. */
+export class DamlContractId {
+    value;
+    constructor(value) {
+        if (value.length === 0) {
+            throw new ValidationError("DAML contract ids must not be empty");
+        }
+        this.value = value;
+    }
+}

package/dist/core/types/daml-values.d.ts

@@ -0,0 +1,35 @@
+import { TemplateId } from "../../query/model-types.js";
+export declare class DamlUnit {
+}
+export declare class DamlDate {
+    readonly daysSinceEpoch: number;
+    constructor(daysSinceEpoch: number);
+}
+export declare class DamlTimestamp {
+    readonly microsecondsSinceEpoch: string;
+    constructor(microsecondsSinceEpoch: string);
+}
+export declare class DamlTextMap {
+    readonly entries: readonly (readonly [string, unknown])[];
+    constructor(entries: readonly (readonly [string, unknown])[]);
+}
+export declare class DamlGenMap {
+    readonly entries: readonly (readonly [unknown, unknown])[];
+    constructor(entries: readonly (readonly [unknown, unknown])[]);
+}
+export declare class DamlVariant {
+    readonly constructorName: string;
+    readonly value: unknown;
+    readonly variantId?: TemplateId | undefined;
+    constructor(constructorName: string, value: unknown, variantId?: TemplateId | undefined);
+}
+export declare class DamlEnum {
+    readonly constructorName: string;
+    readonly enumId?: TemplateId | undefined;
+    constructor(constructorName: string, enumId?: TemplateId | undefined);
+}
+export declare class DamlRecord {
+    readonly fields: Readonly<Record<string, unknown>>;
+    readonly recordId?: TemplateId | undefined;
+    constructor(fields: Readonly<Record<string, unknown>>, recordId?: TemplateId | undefined);
+}

package/dist/core/types/daml-values.js

@@ -0,0 +1,52 @@
+export class DamlUnit {
+}
+export class DamlDate {
+    daysSinceEpoch;
+    constructor(daysSinceEpoch) {
+        this.daysSinceEpoch = daysSinceEpoch;
+    }
+}
+export class DamlTimestamp {
+    microsecondsSinceEpoch;
+    constructor(microsecondsSinceEpoch) {
+        this.microsecondsSinceEpoch = microsecondsSinceEpoch;
+    }
+}
+export class DamlTextMap {
+    entries;
+    constructor(entries) {
+        this.entries = entries;
+    }
+}
+export class DamlGenMap {
+    entries;
+    constructor(entries) {
+        this.entries = entries;
+    }
+}
+export class DamlVariant {
+    constructorName;
+    value;
+    variantId;
+    constructor(constructorName, value, variantId) {
+        this.constructorName = constructorName;
+        this.value = value;
+        this.variantId = variantId;
+    }
+}
+export class DamlEnum {
+    constructorName;
+    enumId;
+    constructor(constructorName, enumId) {
+        this.constructorName = constructorName;
+        this.enumId = enumId;
+    }
+}
+export class DamlRecord {
+    fields;
+    recordId;
+    constructor(fields, recordId) {
+        this.fields = fields;
+        this.recordId = recordId;
+    }
+}

package/dist/index.d.ts

@@ -208,6 +208,8 @@ export type { ExternalPartySigner, ExternalPartySigningRequest, ExternalPartySig
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";
 export { DisclosedContract } from "./core/types/disclosed-contract.js";
 export { PreparedCommandSubmission } from "./core/types/prepared-command-submission.js";
+export { DamlContractId } from "./core/types/daml-contract-id.js";
+export { DamlUnit, DamlDate, DamlTimestamp, DamlTextMap, DamlGenMap, DamlVariant, DamlEnum, DamlRecord } from "./core/types/daml-values.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
 export { AssembleSignedTopologyTransactionsRequest } from "./core/types/requests/assemble-signed-topology-transactions-request.js";

package/dist/index.js

@@ -195,6 +195,8 @@ export { CreateExternalPartyRequest, } from "./core/types/requests/create-extern
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";
 export { DisclosedContract } from "./core/types/disclosed-contract.js";
 export { PreparedCommandSubmission } from "./core/types/prepared-command-submission.js";
+export { DamlContractId } from "./core/types/daml-contract-id.js";
+export { DamlUnit, DamlDate, DamlTimestamp, DamlTextMap, DamlGenMap, DamlVariant, DamlEnum, DamlRecord } from "./core/types/daml-values.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
 export { AssembleSignedTopologyTransactionsRequest } from "./core/types/requests/assemble-signed-topology-transactions-request.js";

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

@@ -55,6 +55,8 @@ export class GrpcContractQueryClient {
         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) {
@@ -99,7 +101,7 @@ export class GrpcContractQueryClient {
 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)
+    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];
@@ -115,7 +117,7 @@ function mapGrpcContract(value) {
         contractId: row.contractId ?? "",
         templateId: { packageId: template?.packageId ?? "", moduleName: template?.moduleName ?? "", entityName: template?.entityName ?? "" },
         packageId: null,
-        payload: undefined,
+        payload: row.payload,
         witnesses: [],
         createdEventOffset: "",
         createdAt: null,
@@ -124,3 +126,24 @@ function mapGrpcContract(value) {
         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/query/model-types.d.ts

@@ -106,9 +106,12 @@ type PayloadValueFilter = {
     readonly gte?: never;
     readonly like?: never;
 };
+export type PayloadMatch = {
+    readonly [field: string]: PayloadMatch | PayloadValueFilter;
+};
 export type ContractPayloadFilter = {
-    readonly path: string;
-} & PayloadValueFilter;
+    readonly match: PayloadMatch;
+};
 type ContractWhereFields = {
     readonly contractId?: StringFilter;
     readonly templateId?: Partial<{

package/dist/query/pqs/pqs-sql-compiler.js

@@ -72,14 +72,15 @@ function compileWhere(where, addValue) {
         }
         if (key === "payload") {
             const payload = value;
-            const path = payload.path;
-            if (typeof path !== "string" || path.split(".").some((x) => x.length === 0))
-                throw new Error("payload path must contain non-empty segments");
-            const ops = ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].filter((op) => payload[op] !== undefined);
-            if (ops.length !== 1 || typeof payload[ops[0]] !== "string")
-                throw new Error("payload requires exactly one string predicate");
-            const op = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[ops[0]];
-            parts.push(`contract_row.payload #>> ${addValue(path.split("."))}::text[] ${op} ${addValue(payload[ops[0]])}`);
+            const compilePayload = (path, filter) => { const ops = ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].filter((op) => filter[op] !== undefined); if (ops.length === 1) {
+                const op = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[ops[0]];
+                parts.push(`contract_row.payload #>> ${addValue(path)}::text[] ${op} ${addValue(filter[ops[0]])}`);
+                return;
+            } for (const [name, child] of Object.entries(filter))
+                compilePayload([...path, name], child); };
+            if (payload.match === undefined)
+                throw new Error("payload requires match");
+            compilePayload([], payload.match);
             continue;
         }
         if (key === "templateId") {

package/dist/transports/grpc/mappers/commands-mapper.js

@@ -4,6 +4,8 @@ import { CreateAndExerciseCommand } from "../../../core/types/commands/create-an
 import { CreateCommand } from "../../../core/types/commands/create-command.js";
 import { DamlNumeric } from "../../../core/types/daml-numeric.js";
 import { DamlParty } from "../../../core/types/daml-party.js";
+import { DamlContractId } from "../../../core/types/daml-contract-id.js";
+import { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp, DamlUnit, DamlVariant } from "../../../core/types/daml-values.js";
 import { ExerciseByKeyCommand } from "../../../core/types/commands/exercise-by-key-command.js";
 import { ExerciseCommand } from "../../../core/types/commands/exercise-command.js";
 import { SubmitCommandResponse } from "../../../core/types/responses/submit-command-response.js";
@@ -103,6 +105,23 @@ export function mapRecord(payload) {
     };
 }
 export function mapValue(value) {
+    const identifier = (value) => ({ packageId: value.packageId, moduleName: value.moduleName, entityName: value.entityName });
+    if (value instanceof DamlUnit)
+        return { sum: { oneofKind: "unit", unit: {} } };
+    if (value instanceof DamlDate)
+        return { sum: { oneofKind: "date", date: value.daysSinceEpoch } };
+    if (value instanceof DamlTimestamp)
+        return { sum: { oneofKind: "timestamp", timestamp: value.microsecondsSinceEpoch } };
+    if (value instanceof DamlTextMap)
+        return { sum: { oneofKind: "textMap", textMap: { entries: value.entries.map(([key, item]) => ({ key, value: mapValue(item) })) } } };
+    if (value instanceof DamlGenMap)
+        return { sum: { oneofKind: "genMap", genMap: { entries: value.entries.map(([key, item]) => ({ key: mapValue(key), value: mapValue(item) })) } } };
+    if (value instanceof DamlVariant)
+        return { sum: { oneofKind: "variant", variant: { variantId: value.variantId && identifier(value.variantId), constructor: value.constructorName, value: mapValue(value.value) } } };
+    if (value instanceof DamlEnum)
+        return { sum: { oneofKind: "enum", enum: { enumId: value.enumId && identifier(value.enumId), constructor: value.constructorName } } };
+    if (value instanceof DamlRecord)
+        return { sum: { oneofKind: "record", record: { recordId: value.recordId && identifier(value.recordId), fields: mapRecord(value.fields).fields } } };
     if (value === null || value === undefined) {
         return {
             sum: {
@@ -119,6 +138,9 @@ export function mapValue(value) {
             },
         };
     }
+    else if (value instanceof DamlContractId) {
+        return { sum: { oneofKind: "contractId", contractId: value.value } };
+    }
     else if (value instanceof DamlNumeric) {
         return {
             sum: {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.8",
+    "version": "0.1.11",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",