@meshtrade/api-old 1.30.0

package/dist/meshtrade/common/config.d.ts

@@ -0,0 +1,7 @@
+export type ConfigOpts = {
+    apiServerURL?: string;
+};
+export type Config = {
+    apiServerURL: string;
+};
+export declare function getConfigFromOpts(config?: ConfigOpts): Config;

package/dist/meshtrade/common/config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigFromOpts = getConfigFromOpts;
+function getConfigFromOpts(config) {
+    const apiServerURL = config?.apiServerURL ?? "http://localhost:10000";
+    return {
+        apiServerURL,
+    };
+}

package/dist/meshtrade/common/groupHeaderInterceptor.d.ts

@@ -0,0 +1,64 @@
+import { Request, UnaryInterceptor, UnaryResponse } from "grpc-web";
+import { Message } from "google-protobuf";
+/**
+ * Interceptor to inject operating group context into an API call
+ * by adding a `x-group` header to the request metadata.
+ *
+ * The group context determines the scope of operations and resource access
+ * within the Meshtrade platform's hierarchical group ownership model.
+ *
+ * This interceptor validates that the provided group follows the correct
+ * resource name format: `groups/{ulid}` where {ulid} is a 26-character
+ * ULID (Universally Unique Lexicographically Sortable Identifier).
+ *
+ * @template TReq The request message type.
+ * @template TResp The response message type.
+ *
+ * @example
+ * ```typescript
+ * // Create an interceptor with a valid group resource name
+ * const interceptor = new GroupHeaderInterceptor('groups/01ARZ3NDEKTSV4YWVF8F5BH32');
+ *
+ * // Use with a gRPC client
+ * const client = new SomeServiceClient(url, null, {
+ *   unaryInterceptors: [interceptor]
+ * });
+ * ```
+ */
+export declare class GroupHeaderInterceptor<TReq extends Message, TResp extends Message> implements UnaryInterceptor<TReq, TResp> {
+    private readonly group;
+    /**
+     * Creates a new GroupHeaderInterceptor instance.
+     *
+     * @param group - The group resource name in the format `groups/{ulid}` where
+     *                {ulid} is a 26-character ULID identifier. This determines
+     *                the operating group context for all API requests.
+     * @throws {Error} If the group format is invalid
+     *
+     * @example
+     * ```typescript
+     * // Valid group format
+     * new GroupHeaderInterceptor('groups/01ARZ3NDEKTSV4YWVF8F5BH32');
+     *
+     * // Invalid formats (will throw errors)
+     * new GroupHeaderInterceptor('01ARZ3NDEKTSV4YWVF8F5BH32'); // Missing "groups/" prefix
+     * new GroupHeaderInterceptor('groups/invalid'); // Invalid ULID format
+     * new GroupHeaderInterceptor('users/01ARZ3NDEKTSV4YWVF8F5BH32'); // Wrong resource type
+     * ```
+     */
+    constructor(group: string);
+    /**
+     * Intercepts the gRPC request to inject the group context into the metadata.
+     *
+     * This method adds an `x-group` header to the request metadata containing
+     * the group resource name. The backend authorization layer uses this header
+     * to determine the operating group scope for the request.
+     *
+     * @param request - The gRPC request to intercept
+     * @param invoker - The function to invoke the actual gRPC call
+     * @returns Promise resolving to the gRPC response
+     *
+     * @override
+     */
+    intercept(request: Request<TReq, TResp>, invoker: (request: Request<TReq, TResp>) => Promise<UnaryResponse<TReq, TResp>>): Promise<UnaryResponse<TReq, TResp>>;
+}

package/dist/meshtrade/common/groupHeaderInterceptor.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupHeaderInterceptor = void 0;
+const validation_1 = require("./validation");
+/**
+ * Interceptor to inject operating group context into an API call
+ * by adding a `x-group` header to the request metadata.
+ *
+ * The group context determines the scope of operations and resource access
+ * within the Meshtrade platform's hierarchical group ownership model.
+ *
+ * This interceptor validates that the provided group follows the correct
+ * resource name format: `groups/{ulid}` where {ulid} is a 26-character
+ * ULID (Universally Unique Lexicographically Sortable Identifier).
+ *
+ * @template TReq The request message type.
+ * @template TResp The response message type.
+ *
+ * @example
+ * ```typescript
+ * // Create an interceptor with a valid group resource name
+ * const interceptor = new GroupHeaderInterceptor('groups/01ARZ3NDEKTSV4YWVF8F5BH32');
+ *
+ * // Use with a gRPC client
+ * const client = new SomeServiceClient(url, null, {
+ *   unaryInterceptors: [interceptor]
+ * });
+ * ```
+ */
+class GroupHeaderInterceptor {
+    /**
+     * Creates a new GroupHeaderInterceptor instance.
+     *
+     * @param group - The group resource name in the format `groups/{ulid}` where
+     *                {ulid} is a 26-character ULID identifier. This determines
+     *                the operating group context for all API requests.
+     * @throws {Error} If the group format is invalid
+     *
+     * @example
+     * ```typescript
+     * // Valid group format
+     * new GroupHeaderInterceptor('groups/01ARZ3NDEKTSV4YWVF8F5BH32');
+     *
+     * // Invalid formats (will throw errors)
+     * new GroupHeaderInterceptor('01ARZ3NDEKTSV4YWVF8F5BH32'); // Missing "groups/" prefix
+     * new GroupHeaderInterceptor('groups/invalid'); // Invalid ULID format
+     * new GroupHeaderInterceptor('users/01ARZ3NDEKTSV4YWVF8F5BH32'); // Wrong resource type
+     * ```
+     */
+    constructor(group) {
+        this.group = group;
+        if (!(0, validation_1.isValidGroupResourceName)(group)) {
+            throw new Error(`Invalid group format: "${group}". Group must be in the format "groups/{ulid}" ` +
+                `where {ulid} is a 26-character ULID (e.g., "groups/01ARZ3NDEKTSV4YWVF8F5BH32").`);
+        }
+    }
+    /**
+     * Intercepts the gRPC request to inject the group context into the metadata.
+     *
+     * This method adds an `x-group` header to the request metadata containing
+     * the group resource name. The backend authorization layer uses this header
+     * to determine the operating group scope for the request.
+     *
+     * @param request - The gRPC request to intercept
+     * @param invoker - The function to invoke the actual gRPC call
+     * @returns Promise resolving to the gRPC response
+     *
+     * @override
+     */
+    intercept(request, invoker) {
+        const metadata = request.getMetadata();
+        metadata["x-group"] = this.group;
+        return invoker(request);
+    }
+}
+exports.GroupHeaderInterceptor = GroupHeaderInterceptor;

package/dist/meshtrade/common/grpc_web.d.ts

@@ -0,0 +1,18 @@
+import { UnaryInterceptor, Request, UnaryResponse } from "grpc-web";
+/**
+ * `LoggingInterceptor` is a class responsible for intercepting requests and logging out requests and responses.
+ */
+export declare class LoggingInterceptor implements UnaryInterceptor<unknown, unknown> {
+    /**
+     * Intercepts a request to add the loggingorization token to its metadata.
+     *
+     * @param {Object} request - The request object.
+     * @param {Function} request.getMetadata - A function that returns the request's metadata.
+     * @param {unknown} invoker - A function responsible for processing the request.
+     *                            Expected to be of type `function`, but can be of any type.
+     *
+     * @returns {unknown} The result of the `invoker` function, if it is a function.
+     *                    Otherwise, logs an error and doesn't return anything.
+     */
+    intercept(request: Request<unknown, unknown>, invoker: (request: Request<unknown, unknown>) => Promise<UnaryResponse<unknown, unknown>>): Promise<UnaryResponse<unknown, unknown>>;
+}

package/dist/meshtrade/common/grpc_web.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingInterceptor = void 0;
+/**
+ * `LoggingInterceptor` is a class responsible for intercepting requests and logging out requests and responses.
+ */
+class LoggingInterceptor {
+    /**
+     * Intercepts a request to add the loggingorization token to its metadata.
+     *
+     * @param {Object} request - The request object.
+     * @param {Function} request.getMetadata - A function that returns the request's metadata.
+     * @param {unknown} invoker - A function responsible for processing the request.
+     *                            Expected to be of type `function`, but can be of any type.
+     *
+     * @returns {unknown} The result of the `invoker` function, if it is a function.
+     *                    Otherwise, logs an error and doesn't return anything.
+     */
+    async intercept(request, invoker) {
+        // log request
+        console.debug("request: ", request.getMethodDescriptor().getName(), request);
+        // perform grpc call in a try catch so that error can be logged
+        try {
+            const response = await invoker(request);
+            console.debug("response: ", request.getMethodDescriptor().getName(), response);
+            return response;
+        }
+        catch (e) {
+            console.error(`error: ${request.getMethodDescriptor().getName()}`, e);
+            throw e;
+        }
+    }
+}
+exports.LoggingInterceptor = LoggingInterceptor;

package/dist/meshtrade/common/validation.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Generic validation utilities for Meshtrade API resource names and identifiers.
+ */
+/**
+ * Validates if a string is a valid ULID (Universally Unique Lexicographically Sortable Identifier).
+ *
+ * Note: This implementation uses a simplified character set for ULIDs that includes
+ * all uppercase letters A-Z and digits 0-9, unlike the standard ULID specification
+ * which excludes certain ambiguous characters (I, L, O, U).
+ *
+ * ULIDs in this system are 26-character identifiers that are:
+ * - Lexicographically sortable
+ * - Uppercase alphanumeric only
+ * - Contain timestamp information for natural ordering
+ *
+ * @param ulid - The string to validate as a ULID
+ * @returns true if the string is a valid ULID format, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidULID('01ARZ3NDEKTSV4YWVF8F5BH32'); // true
+ * isValidULID('invalid'); // false
+ * isValidULID('01arz3ndektsv4ywvf8f5bh32'); // false (lowercase)
+ * ```
+ */
+export declare function isValidULID(ulid: string): boolean;
+/**
+ * Validates if a resource name follows the groups/{ulid} format.
+ *
+ * Group resource names in the Meshtrade API follow the pattern "groups/{ulid}"
+ * where {ulid} is a 26-character ULID identifier.
+ *
+ * @param resourceName - The resource name string to validate
+ * @returns true if the resource name is a valid group resource name, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidGroupResourceName('groups/01ARZ3NDEKTSV4YWVF8F5BH32'); // true
+ * isValidGroupResourceName('groups/invalid'); // false
+ * isValidGroupResourceName('users/01ARZ3NDEKTSV4YWVF8F5BH32'); // false
+ * isValidGroupResourceName('01ARZ3NDEKTSV4YWVF8F5BH32'); // false
+ * ```
+ */
+export declare function isValidGroupResourceName(resourceName: string): boolean;
+/**
+ * Validates a protobuf request message before sending to the server.
+ *
+ * This function serves as a client-side validation hook that can be extended
+ * to include protovalidate integration or other validation logic.
+ *
+ * Currently performs basic null/undefined checks. Future enhancements may include
+ * protovalidate integration for comprehensive message validation.
+ *
+ * @param request - The protobuf request message to validate
+ * @throws {Error} If the request is null or undefined
+ *
+ * @example
+ * ```typescript
+ * validateRequest(myRequest); // Throws if request is invalid
+ * ```
+ */
+export declare function validateRequest(request: unknown): void;

package/dist/meshtrade/common/validation.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Generic validation utilities for Meshtrade API resource names and identifiers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidULID = isValidULID;
+exports.isValidGroupResourceName = isValidGroupResourceName;
+exports.validateRequest = validateRequest;
+/**
+ * Validates if a string is a valid ULID (Universally Unique Lexicographically Sortable Identifier).
+ *
+ * Note: This implementation uses a simplified character set for ULIDs that includes
+ * all uppercase letters A-Z and digits 0-9, unlike the standard ULID specification
+ * which excludes certain ambiguous characters (I, L, O, U).
+ *
+ * ULIDs in this system are 26-character identifiers that are:
+ * - Lexicographically sortable
+ * - Uppercase alphanumeric only
+ * - Contain timestamp information for natural ordering
+ *
+ * @param ulid - The string to validate as a ULID
+ * @returns true if the string is a valid ULID format, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidULID('01ARZ3NDEKTSV4YWVF8F5BH32'); // true
+ * isValidULID('invalid'); // false
+ * isValidULID('01arz3ndektsv4ywvf8f5bh32'); // false (lowercase)
+ * ```
+ */
+function isValidULID(ulid) {
+    return /^[0-9A-Z]{26}$/.test(ulid);
+}
+/**
+ * Validates if a resource name follows the groups/{ulid} format.
+ *
+ * Group resource names in the Meshtrade API follow the pattern "groups/{ulid}"
+ * where {ulid} is a 26-character ULID identifier.
+ *
+ * @param resourceName - The resource name string to validate
+ * @returns true if the resource name is a valid group resource name, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidGroupResourceName('groups/01ARZ3NDEKTSV4YWVF8F5BH32'); // true
+ * isValidGroupResourceName('groups/invalid'); // false
+ * isValidGroupResourceName('users/01ARZ3NDEKTSV4YWVF8F5BH32'); // false
+ * isValidGroupResourceName('01ARZ3NDEKTSV4YWVF8F5BH32'); // false
+ * ```
+ */
+function isValidGroupResourceName(resourceName) {
+    return /^groups\/[0-9A-Z]{26}$/.test(resourceName);
+}
+/**
+ * Validates a protobuf request message before sending to the server.
+ *
+ * This function serves as a client-side validation hook that can be extended
+ * to include protovalidate integration or other validation logic.
+ *
+ * Currently performs basic null/undefined checks. Future enhancements may include
+ * protovalidate integration for comprehensive message validation.
+ *
+ * @param request - The protobuf request message to validate
+ * @throws {Error} If the request is null or undefined
+ *
+ * @example
+ * ```typescript
+ * validateRequest(myRequest); // Throws if request is invalid
+ * ```
+ */
+function validateRequest(request) {
+    if (request === null || request === undefined) {
+        throw new Error("Request cannot be null or undefined");
+    }
+    // Future: Integrate protovalidate for comprehensive message validation
+    // For now, basic validation is sufficient as the server also validates
+}

package/dist/meshtrade/compliance/client/v1/client_pb.d.ts

@@ -0,0 +1,91 @@
+import * as jspb from 'google-protobuf'
+
+import * as buf_validate_validate_pb from '../../../../buf/validate/validate_pb'; // proto import: "buf/validate/validate.proto"
+import * as google_protobuf_timestamp_pb from 'google-protobuf/google/protobuf/timestamp_pb'; // proto import: "google/protobuf/timestamp.proto"
+import * as meshtrade_compliance_client_v1_company_pb from '../../../../meshtrade/compliance/client/v1/company_pb'; // proto import: "meshtrade/compliance/client/v1/company.proto"
+import * as meshtrade_compliance_client_v1_fund_pb from '../../../../meshtrade/compliance/client/v1/fund_pb'; // proto import: "meshtrade/compliance/client/v1/fund.proto"
+import * as meshtrade_compliance_client_v1_natural_person_pb from '../../../../meshtrade/compliance/client/v1/natural_person_pb'; // proto import: "meshtrade/compliance/client/v1/natural_person.proto"
+import * as meshtrade_compliance_client_v1_trust_pb from '../../../../meshtrade/compliance/client/v1/trust_pb'; // proto import: "meshtrade/compliance/client/v1/trust.proto"
+import * as meshtrade_compliance_client_v1_verification_status_pb from '../../../../meshtrade/compliance/client/v1/verification_status_pb'; // proto import: "meshtrade/compliance/client/v1/verification_status.proto"
+
+
+export class Client extends jspb.Message {
+  getName(): string;
+  setName(value: string): Client;
+
+  getOwner(): string;
+  setOwner(value: string): Client;
+
+  getDisplayName(): string;
+  setDisplayName(value: string): Client;
+
+  getNaturalPerson(): meshtrade_compliance_client_v1_natural_person_pb.NaturalPerson | undefined;
+  setNaturalPerson(value?: meshtrade_compliance_client_v1_natural_person_pb.NaturalPerson): Client;
+  hasNaturalPerson(): boolean;
+  clearNaturalPerson(): Client;
+
+  getCompany(): meshtrade_compliance_client_v1_company_pb.Company | undefined;
+  setCompany(value?: meshtrade_compliance_client_v1_company_pb.Company): Client;
+  hasCompany(): boolean;
+  clearCompany(): Client;
+
+  getFund(): meshtrade_compliance_client_v1_fund_pb.Fund | undefined;
+  setFund(value?: meshtrade_compliance_client_v1_fund_pb.Fund): Client;
+  hasFund(): boolean;
+  clearFund(): Client;
+
+  getTrust(): meshtrade_compliance_client_v1_trust_pb.Trust | undefined;
+  setTrust(value?: meshtrade_compliance_client_v1_trust_pb.Trust): Client;
+  hasTrust(): boolean;
+  clearTrust(): Client;
+
+  getVerificationStatus(): meshtrade_compliance_client_v1_verification_status_pb.VerificationStatus;
+  setVerificationStatus(value: meshtrade_compliance_client_v1_verification_status_pb.VerificationStatus): Client;
+
+  getVerificationAuthority(): string;
+  setVerificationAuthority(value: string): Client;
+
+  getVerificationDate(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setVerificationDate(value?: google_protobuf_timestamp_pb.Timestamp): Client;
+  hasVerificationDate(): boolean;
+  clearVerificationDate(): Client;
+
+  getNextVerificationDate(): google_protobuf_timestamp_pb.Timestamp | undefined;
+  setNextVerificationDate(value?: google_protobuf_timestamp_pb.Timestamp): Client;
+  hasNextVerificationDate(): boolean;
+  clearNextVerificationDate(): Client;
+
+  getLegalPersonCase(): Client.LegalPersonCase;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Client.AsObject;
+  static toObject(includeInstance: boolean, msg: Client): Client.AsObject;
+  static serializeBinaryToWriter(message: Client, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Client;
+  static deserializeBinaryFromReader(message: Client, reader: jspb.BinaryReader): Client;
+}
+
+export namespace Client {
+  export type AsObject = {
+    name: string,
+    owner: string,
+    displayName: string,
+    naturalPerson?: meshtrade_compliance_client_v1_natural_person_pb.NaturalPerson.AsObject,
+    company?: meshtrade_compliance_client_v1_company_pb.Company.AsObject,
+    fund?: meshtrade_compliance_client_v1_fund_pb.Fund.AsObject,
+    trust?: meshtrade_compliance_client_v1_trust_pb.Trust.AsObject,
+    verificationStatus: meshtrade_compliance_client_v1_verification_status_pb.VerificationStatus,
+    verificationAuthority: string,
+    verificationDate?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+    nextVerificationDate?: google_protobuf_timestamp_pb.Timestamp.AsObject,
+  }
+
+  export enum LegalPersonCase { 
+    LEGAL_PERSON_NOT_SET = 0,
+    NATURAL_PERSON = 4,
+    COMPANY = 5,
+    FUND = 6,
+    TRUST = 7,
+  }
+}
+