@genesislcap/mock-server 15.51.1 → 15.53.0

package/dist/protocol/errors.d.ts

@@ -1,17 +1,115 @@
+declare const ERROR_CODES: {
+    readonly GENERIC_ERROR: readonly ["Something is wrong", "500 Internal Server Error"];
+    readonly MISSING_FIELD: readonly ["Field is missing", "400 Bad Request"];
+    readonly VALIDATION_ERROR: readonly ["Message failed validation", "400 Bad Request"];
+    readonly INVALID_MESSAGE: readonly ["Invalid message or invalid message format", "400 Bad Request"];
+    readonly NOT_SUPPORTED_ENUM_VALUE: readonly ["Enum value not supported", "400 Bad Request"];
+    readonly NOT_AUTHORISED: readonly ["Not authorised", "403 Forbidden"];
+    readonly DUPLICATE_KEY: readonly ["Record conflicts with unique index already stored in the database", "500 Internal Server Error"];
+    readonly INVALID_MESSAGE_TYPE: readonly ["Invalid message type", "400 Bad Request"];
+    readonly INVALID_DATASOURCE: readonly ["Invalid DATASOURCE_NAME", "400 Bad Request"];
+    readonly INVALID_PARAMETER: readonly ["MOVING_VIEW can't be true if maxView is set to 0", "400 Bad Request"];
+    readonly LOGIN_ERROR: readonly ["There was a problem logging in to the SOAP WebService", "401 Unauthorized"];
+    readonly MULTIPLE_TABLES: readonly ["Only one table can be referred", "500 Internal Server Error"];
+    readonly MISSING_KEY: readonly ["Key name must be provided", "400 Bad Request"];
+    readonly UNKNOWN_TABLE: readonly ["No such table", "400 Bad Request"];
+    readonly UNKNOWN_FIELD: readonly ["No such field on table", "400 Bad Request"];
+    readonly UNKNOWN: readonly ["Unknown error", "500 Internal Server Error"];
+    readonly NO_MESSAGE_TYPE: readonly ["No message type provided", "400 Bad Request"];
+    readonly NO_SOURCE_REF: readonly ["No source ref provided", "400 Bad Request"];
+    readonly NO_USER_NAME: readonly ["No user name provided", "400 Bad Request"];
+    readonly UNAVAILABLE: readonly ["Process is currently unavailable", "503 Service Unavailable"];
+    readonly UNKNOWN_MESSAGE_TYPE: readonly ["Message type not supported", "400 Bad Request"];
+    readonly FEATURE_NOT_PROVIDED: readonly ["Feature not provided", "400 Bad Request"];
+    readonly FEATURE_NOT_FOUND: readonly ["Feature not found", "404 Not Found"];
+    readonly JSON_SCHEMA_NOT_FOUND: readonly ["JSON schema not found", "404 Not Found"];
+    readonly REJECT_RULE_DOES_NOT_EXIST: readonly ["Failed to find Dynamic Rule", "404 Not Found"];
+    readonly ERROR_CHECKING_EXISTING_RULE: readonly ["Error while checking for rule", "400 Bad Request"];
+    readonly NO_DS_NAME: readonly ["No data source provided", "400 Bad Request"];
+    readonly INVALID_DS_NAME: readonly ["Data source does not exist", "404 Not Found"];
+    readonly INVALID_INDEX: readonly ["Invalid index", "400 Bad Request"];
+    readonly REJECT_RULE_MISSING: readonly ["Rule does not exist", "404 Not Found"];
+    readonly ERROR_MODIFYING_RULE: readonly ["Error encountered trying to modify rule", "500 Internal Server Error"];
+    readonly INVALID_CRITERIA: readonly ["Criteria has failed validation", "400 Bad Request"];
+    readonly MAX_LOGON_LIMIT: readonly ["Tried to connect too many times", "429 Too Many Requests"];
+    readonly RECORD_NOT_FOUND: readonly ["No record found for given key data", "404 Not Found"];
+    readonly SERVICE_NOT_FOUND: readonly ["No service found", "404 Not Found"];
+    readonly DATABASE_FAILURE: readonly ["There was an internal database error", "500 Internal Server Error"];
+    readonly DATABASE_ERROR: readonly ["Database error", "500 Internal Server Error"];
+    readonly OPERATION_TIMEOUT: readonly ["Server timed out", "408 Request Timeout"];
+    readonly DEPENDENT_RECORD_FOUND: readonly ["Dependency found on other records for changed value(s)", "500 Internal Server Error"];
+    readonly REQUIRES_APPROVAL: readonly ["Transaction requires approval", "403 Forbidden"];
+    readonly APPROVAL_MESSAGE_MISSING: readonly ["Transaction requires approval, but the approval message is missing", "400 Bad Request"];
+    readonly INTERNAL_ERROR: readonly ["Unexpected server error", "500 Internal Server Error"];
+    readonly GATEWAY_ERROR: readonly ["Notify gateway error", "400 Bad Request"];
+    readonly REQUEST_FAILED: readonly ["Problem handling request", "400 Bad Request"];
+    readonly UNABLE_TO_UPDATE_APPROVAL: readonly ["Pending approval error, unable to update approval", "500 Internal Server Error"];
+    readonly APPROVAL_SAME_USER_CANNOT_ACCEPT: readonly ["Pending approval error, same user cannot accept", "400 Bad Request"];
+    readonly APPROVAL_RECORD_NOT_FOUND: readonly ["Pending approval record not found", "404 Not Found"];
+    readonly REJECTED_BY_SERVICE: readonly ["Pending approval rejected by service", "500 Internal Server Error"];
+    readonly APPROVAL_DIFF_USER_CANNOT_CANCEL: readonly ["Pending approval different user cannot cancel", "400 Bad Request"];
+    readonly APPROVAL_WRONG_STATUS_CANNOT_CANCEL: readonly ["Pending approval error, wrong status cannot cancel", "400 Bad Request"];
+    readonly APPROVAL_WRONG_STATUS_CANNOT_ACCEPT: readonly ["Pending approval error, wrong status cannot accept", "400 Bad Request"];
+    readonly APPROVAL_SAME_USER_CANNOT_REJECT: readonly ["Pending approval error, same user cannot reject", "400 Bad Request"];
+    readonly APPROVAL_WRONG_STATUS_CANNOT_REJECT: readonly ["Pending approval error, wrong status cannot reject", "400 Bad Request"];
+    readonly MISSING_HOSTNAME: readonly ["Missing hostname", "400 Bad Request"];
+    readonly NUMBER_OF_RECORDS_DOES_NOT_MATCH: readonly ["Event nack, Number of keys and records does not match", "400 Bad Request"];
+    readonly OPTIMISTIC_CONCURRENCY_ERROR: readonly ["Optimistic concurrency error", "400 Bad Request"];
+};
+export type ErrorCodeName = keyof typeof ERROR_CODES;
+export declare const ErrorCode: { readonly [Name in ErrorCodeName]: Name; };
+export declare function statusCodeFor(code: string): string;
+export declare function defaultTextFor(code: string): string | undefined;
+export type GenesisErrorType = 'StandardError' | 'FieldError' | 'TableStandardError' | 'LoginError';
 export interface NackErrorInput {
+    '@type'?: GenesisErrorType;
     CODE?: string;
     code?: string;
     TEXT?: string;
     text?: string;
+    STATUS_CODE?: string;
+    statusCode?: string;
     FIELD?: string;
     field?: string;
+    PATH?: string | null;
+    path?: string | null;
+    TABLE?: string;
+    table?: string;
 }
 export interface NackErrorEntry {
+    '@type'?: GenesisErrorType;
     CODE: string;
     TEXT: string;
-    FIELD?: string;
+    STATUS_CODE?: string;
+    FIELD?: string | null;
+    PATH?: string | null;
+    TABLE?: string | null;
+    DETAILS?: null;
+}
+export declare function toNackEntry(input: NackErrorInput): NackErrorEntry;
+export declare function toLegacyNackEntry(input: NackErrorInput): NackErrorEntry;
+export interface NackErrorOptions {
+    warnings?: NackErrorInput | NackErrorInput[];
 }
 export declare class NackError extends Error {
     readonly errors: NackErrorEntry[];
-    constructor(errors: NackErrorInput | NackErrorInput[]);
+    readonly warnings: NackErrorEntry[];
+    readonly inputs: readonly NackErrorInput[];
+    readonly warningInputs: readonly NackErrorInput[];
+    constructor(errors: string | NackErrorInput | NackErrorInput[], options?: NackErrorOptions);
+    static field(field: string, text: string, path?: string | null, code?: string): NackError;
+    static standard(code: string, text?: string): NackError;
+    static duplicateKey(table: string, index: string, value: unknown, text?: string): NackError;
+    static recordNotFound(table: string, index?: string, text?: string): NackError;
+    static nack(text: string): NackError;
+    static warning(warnings: string | NackErrorInput | NackErrorInput[]): NackError;
 }
+export declare function nackPayload(error: unknown, legacy: boolean): {
+    ERROR: NackErrorEntry[];
+    WARNING?: NackErrorEntry[];
+};
+export declare function warningPayload(warnings: NackErrorInput[], legacy: boolean): {
+    ERROR: NackErrorEntry[];
+    WARNING?: NackErrorEntry[];
+};
+export {};

package/dist/protocol/errors.js

@@ -1,16 +1,304 @@
-// Throw this from an event handler / request-reply resolver to produce a
-// protocol-correct *_NACK with ERROR as an array of {CODE, TEXT, FIELD?} —
-// never {error, details} (lowercase, non-array), which crashes real clients
-// calling .forEach on the wrong shape.
+// The error vocabulary of service NACKs (EVENT_NACK, REP_* errors), as GSF
+// 8.15.x serializes it: genesis-messages' GenesisError family
+// (global.genesis.message.core.error.GenesisError.kt) and the ErrorCode enum
+// (ErrorCode.kt). Every item names its class in `@type`, carries a string
+// CODE, TEXT and a "<code> <reason>" STATUS_CODE, plus the class's own
+// fields; the envelope carries WARNING next to ERROR. Checked against frames
+// recorded from a GSF 8.15.29 app (test/conformance/recordings).
+//
+// The router's MSG_NACK is a different family (no @type, an integer CODE,
+// DETAILS {ERROR, STATUS_CODE}) — see msgNack.ts.
+// HttpStatusCode.kt's status lines ("$code $description") for the statuses
+// ErrorCode uses.
+const BAD_REQUEST = '400 Bad Request';
+const UNAUTHORIZED = '401 Unauthorized';
+const FORBIDDEN = '403 Forbidden';
+const NOT_FOUND = '404 Not Found';
+const REQUEST_TIMEOUT = '408 Request Timeout';
+const TOO_MANY_REQUESTS = '429 Too Many Requests';
+const INTERNAL_SERVER_ERROR = '500 Internal Server Error';
+const SERVICE_UNAVAILABLE = '503 Service Unavailable';
+// [readable text, HTTP status line] per ErrorCode.kt entry, in the enum's order.
+// The readable text is what StandardError(ErrorCode.X) sends as TEXT when the
+// caller gives none.
+const ERROR_CODES = {
+    GENERIC_ERROR: ['Something is wrong', INTERNAL_SERVER_ERROR],
+    MISSING_FIELD: ['Field is missing', BAD_REQUEST],
+    VALIDATION_ERROR: ['Message failed validation', BAD_REQUEST],
+    INVALID_MESSAGE: ['Invalid message or invalid message format', BAD_REQUEST],
+    NOT_SUPPORTED_ENUM_VALUE: ['Enum value not supported', BAD_REQUEST],
+    NOT_AUTHORISED: ['Not authorised', FORBIDDEN],
+    DUPLICATE_KEY: [
+        'Record conflicts with unique index already stored in the database',
+        INTERNAL_SERVER_ERROR,
+    ],
+    INVALID_MESSAGE_TYPE: ['Invalid message type', BAD_REQUEST],
+    INVALID_DATASOURCE: ['Invalid DATASOURCE_NAME', BAD_REQUEST],
+    INVALID_PARAMETER: ["MOVING_VIEW can't be true if maxView is set to 0", BAD_REQUEST],
+    LOGIN_ERROR: ['There was a problem logging in to the SOAP WebService', UNAUTHORIZED],
+    MULTIPLE_TABLES: ['Only one table can be referred', INTERNAL_SERVER_ERROR],
+    MISSING_KEY: ['Key name must be provided', BAD_REQUEST],
+    UNKNOWN_TABLE: ['No such table', BAD_REQUEST],
+    UNKNOWN_FIELD: ['No such field on table', BAD_REQUEST],
+    UNKNOWN: ['Unknown error', INTERNAL_SERVER_ERROR],
+    NO_MESSAGE_TYPE: ['No message type provided', BAD_REQUEST],
+    NO_SOURCE_REF: ['No source ref provided', BAD_REQUEST],
+    NO_USER_NAME: ['No user name provided', BAD_REQUEST],
+    UNAVAILABLE: ['Process is currently unavailable', SERVICE_UNAVAILABLE],
+    UNKNOWN_MESSAGE_TYPE: ['Message type not supported', BAD_REQUEST],
+    FEATURE_NOT_PROVIDED: ['Feature not provided', BAD_REQUEST],
+    FEATURE_NOT_FOUND: ['Feature not found', NOT_FOUND],
+    JSON_SCHEMA_NOT_FOUND: ['JSON schema not found', NOT_FOUND],
+    REJECT_RULE_DOES_NOT_EXIST: ['Failed to find Dynamic Rule', NOT_FOUND],
+    ERROR_CHECKING_EXISTING_RULE: ['Error while checking for rule', BAD_REQUEST],
+    NO_DS_NAME: ['No data source provided', BAD_REQUEST],
+    INVALID_DS_NAME: ['Data source does not exist', NOT_FOUND],
+    INVALID_INDEX: ['Invalid index', BAD_REQUEST],
+    REJECT_RULE_MISSING: ['Rule does not exist', NOT_FOUND],
+    ERROR_MODIFYING_RULE: ['Error encountered trying to modify rule', INTERNAL_SERVER_ERROR],
+    INVALID_CRITERIA: ['Criteria has failed validation', BAD_REQUEST],
+    MAX_LOGON_LIMIT: ['Tried to connect too many times', TOO_MANY_REQUESTS],
+    RECORD_NOT_FOUND: ['No record found for given key data', NOT_FOUND],
+    SERVICE_NOT_FOUND: ['No service found', NOT_FOUND],
+    DATABASE_FAILURE: ['There was an internal database error', INTERNAL_SERVER_ERROR],
+    DATABASE_ERROR: ['Database error', INTERNAL_SERVER_ERROR],
+    OPERATION_TIMEOUT: ['Server timed out', REQUEST_TIMEOUT],
+    DEPENDENT_RECORD_FOUND: [
+        'Dependency found on other records for changed value(s)',
+        INTERNAL_SERVER_ERROR,
+    ],
+    REQUIRES_APPROVAL: ['Transaction requires approval', FORBIDDEN],
+    APPROVAL_MESSAGE_MISSING: [
+        'Transaction requires approval, but the approval message is missing',
+        BAD_REQUEST,
+    ],
+    INTERNAL_ERROR: ['Unexpected server error', INTERNAL_SERVER_ERROR],
+    GATEWAY_ERROR: ['Notify gateway error', BAD_REQUEST],
+    REQUEST_FAILED: ['Problem handling request', BAD_REQUEST],
+    UNABLE_TO_UPDATE_APPROVAL: [
+        'Pending approval error, unable to update approval',
+        INTERNAL_SERVER_ERROR,
+    ],
+    APPROVAL_SAME_USER_CANNOT_ACCEPT: [
+        'Pending approval error, same user cannot accept',
+        BAD_REQUEST,
+    ],
+    APPROVAL_RECORD_NOT_FOUND: ['Pending approval record not found', NOT_FOUND],
+    REJECTED_BY_SERVICE: ['Pending approval rejected by service', INTERNAL_SERVER_ERROR],
+    APPROVAL_DIFF_USER_CANNOT_CANCEL: ['Pending approval different user cannot cancel', BAD_REQUEST],
+    APPROVAL_WRONG_STATUS_CANNOT_CANCEL: [
+        'Pending approval error, wrong status cannot cancel',
+        BAD_REQUEST,
+    ],
+    APPROVAL_WRONG_STATUS_CANNOT_ACCEPT: [
+        'Pending approval error, wrong status cannot accept',
+        BAD_REQUEST,
+    ],
+    APPROVAL_SAME_USER_CANNOT_REJECT: [
+        'Pending approval error, same user cannot reject',
+        BAD_REQUEST,
+    ],
+    APPROVAL_WRONG_STATUS_CANNOT_REJECT: [
+        'Pending approval error, wrong status cannot reject',
+        BAD_REQUEST,
+    ],
+    MISSING_HOSTNAME: ['Missing hostname', BAD_REQUEST],
+    NUMBER_OF_RECORDS_DOES_NOT_MATCH: [
+        'Event nack, Number of keys and records does not match',
+        BAD_REQUEST,
+    ],
+    OPTIMISTIC_CONCURRENCY_ERROR: ['Optimistic concurrency error', BAD_REQUEST],
+};
+// GSF's ErrorCode names, for CODE values: ErrorCode.DUPLICATE_KEY ===
+// 'DUPLICATE_KEY'. CODE is a plain string on the wire, so a project's own
+// codes work too (their STATUS_CODE defaults to 500, as StandardError's does).
+export const ErrorCode = Object.fromEntries(Object.keys(ERROR_CODES).map((name) => [name, name]));
+// Codes that aren't in ErrorCode.kt but do appear in platform NACKs.
+const EXTRA_STATUSES = {
+    INCORRECT_CREDENTIALS: UNAUTHORIZED, // platform-auth's LoginError
+};
+function knownCode(code) {
+    return Object.hasOwn(ERROR_CODES, code) ? ERROR_CODES[code] : undefined;
+}
+// The "<code> <reason>" STATUS_CODE for a CODE: the ErrorCode's own status,
+// or 500 for codes GSF doesn't know (GenesisError's default statusCode).
+export function statusCodeFor(code) {
+    return knownCode(code)?.[1] ?? EXTRA_STATUSES[code] ?? INTERNAL_SERVER_ERROR;
+}
+// ErrorCode's readable text, used as TEXT when an error gives none.
+export function defaultTextFor(code) {
+    return knownCode(code)?.[0];
+}
+const LEGACY_DEFAULT_CODE = 'VALIDATION_ERROR';
+const UNKNOWN_TEXT = 'Unknown error';
+function inferType(input) {
+    if (input['@type'])
+        return input['@type'];
+    if ((input.TABLE ?? input.table) !== undefined)
+        return 'TableStandardError';
+    const hasField = (input.FIELD ?? input.field) !== undefined;
+    const hasPath = (input.PATH ?? input.path) !== undefined;
+    return hasField || hasPath ? 'FieldError' : 'StandardError';
+}
+// Renders one input as GSF serializes the matching GenesisError subclass,
+// keys in the same order. Nullable class fields are sent as null, as
+// FieldError's PATH is on the wire.
+export function toNackEntry(input) {
+    const type = inferType(input);
+    const CODE = input.CODE ??
+        input.code ??
+        (type === 'FieldError' ? ErrorCode.VALIDATION_ERROR : ErrorCode.REQUEST_FAILED);
+    const TEXT = input.TEXT ?? input.text ?? defaultTextFor(CODE) ?? UNKNOWN_TEXT;
+    const entry = {
+        '@type': type,
+        CODE,
+        TEXT,
+        STATUS_CODE: input.STATUS_CODE ?? input.statusCode ?? statusCodeFor(CODE),
+    };
+    const field = input.FIELD ?? input.field;
+    switch (type) {
+        case 'FieldError':
+            entry.FIELD = field ?? '';
+            entry.PATH = input.PATH ?? input.path ?? null;
+            break;
+        case 'TableStandardError':
+            entry.TABLE = input.TABLE ?? input.table ?? null;
+            entry.FIELD = field ?? null;
+            break;
+        case 'LoginError':
+            entry.DETAILS = null;
+            break;
+        default:
+            if (field !== undefined)
+                entry.FIELD = field;
+    }
+    return entry;
+}
+// The {CODE, TEXT, FIELD?} item this engine sent up to 15.47, for
+// fidelity: 'legacy' (a helper's code still lends its readable text).
+export function toLegacyNackEntry(input) {
+    const field = input.FIELD ?? input.field;
+    const code = input.CODE ?? input.code;
+    return {
+        CODE: code ?? LEGACY_DEFAULT_CODE,
+        TEXT: input.TEXT ?? input.text ?? (code && defaultTextFor(code)) ?? UNKNOWN_TEXT,
+        ...(field ? { FIELD: field } : {}),
+    };
+}
+function asList(inputs) {
+    if (inputs === undefined)
+        return [];
+    if (typeof inputs === 'string')
+        return [{ TEXT: inputs }];
+    return Array.isArray(inputs) ? inputs : [inputs];
+}
+// Throw this from an event handler or request-reply resolver for a
+// protocol-correct NACK: ERROR is always an array of items, never
+// {error, details} (lowercase, non-array), which crashes real clients calling
+// .forEach on it. Pass a string for a failed GPAL require() (StandardError
+// REQUEST_FAILED, 400), one input, or several to report every failing field
+// at once, as a handler's EventNack(error = listOf(...)) does. The static
+// helpers build the platform's common errors, nack() included.
 export class NackError extends Error {
     errors;
-    constructor(errors) {
-        const list = Array.isArray(errors) ? errors : [errors];
-        super(list.map((e) => e.TEXT ?? e.text ?? 'Unknown error').join(', '));
-        this.errors = list.map((e) => ({
-            CODE: e.CODE ?? e.code ?? 'VALIDATION_ERROR',
-            TEXT: e.TEXT ?? e.text ?? 'Unknown error',
-            ...(e.FIELD || e.field ? { FIELD: e.FIELD ?? e.field } : {}),
-        }));
+    warnings;
+    inputs;
+    warningInputs;
+    constructor(errors, options = {}) {
+        const inputs = asList(errors);
+        const warningInputs = asList(options.warnings);
+        const entries = inputs.map(toNackEntry);
+        const warnings = warningInputs.map(toNackEntry);
+        super([...entries, ...warnings].map((entry) => entry.TEXT).join(', ') || UNKNOWN_TEXT);
+        this.name = 'NackError';
+        this.inputs = inputs;
+        this.warningInputs = warningInputs;
+        this.errors = entries;
+        this.warnings = warnings;
+    }
+    // A FieldError: VALIDATION_ERROR (400) naming the field. PATH is the JSON
+    // path the error was found at — null (the default) for a handler's own
+    // check, '$.DETAILS...' for a schema failure. Forms highlight FIELD/PATH,
+    // and the AI assistant reads a null PATH as "the app said no".
+    static field(field, text, path = null, code = ErrorCode.VALIDATION_ERROR) {
+        return new NackError({
+            '@type': 'FieldError',
+            CODE: code,
+            TEXT: text,
+            FIELD: field,
+            PATH: path,
+        });
     }
+    // A StandardError with a GSF ErrorCode (or a project's own code), TEXT
+    // defaulting to the code's readable text: NackError.standard('NOT_AUTHORISED').
+    static standard(code, text) {
+        return new NackError({ '@type': 'StandardError', CODE: code, TEXT: text });
+    }
+    // The insert that hits an existing key: TableStandardError DUPLICATE_KEY
+    // (500), FIELD '<INDEX_NAME> -> <value>', e.g.
+    // NackError.duplicateKey('COUNTERPARTY', 'COUNTERPARTY_BY_ID', 'CP001').
+    static duplicateKey(table, index, value, text) {
+        return new NackError({
+            '@type': 'TableStandardError',
+            CODE: ErrorCode.DUPLICATE_KEY,
+            TEXT: text,
+            TABLE: table,
+            FIELD: `${index} -> ${String(value)}`,
+        });
+    }
+    // A modify or delete of a record that isn't there: TableStandardError
+    // RECORD_NOT_FOUND (404). GSF names the unique index in FIELD for a modify
+    // and sends '' for a delete, so `index` defaults to ''.
+    static recordNotFound(table, index = '', text) {
+        return new NackError({
+            '@type': 'TableStandardError',
+            CODE: ErrorCode.RECORD_NOT_FOUND,
+            TEXT: text,
+            TABLE: table,
+            FIELD: index,
+        });
+    }
+    // GPAL's nack("text"): GSF wraps the text in an Exception, which
+    // EventHandlerUtils.handleError answers with StandardError INTERNAL_ERROR
+    // (500) carrying the text. (A failed require() is `new NackError(text)`.)
+    static nack(text) {
+        return new NackError({ '@type': 'StandardError', CODE: ErrorCode.INTERNAL_ERROR, TEXT: text });
+    }
+    // A NACK that only warns: ERROR stays empty, WARNING carries these.
+    static warning(warnings) {
+        return new NackError([], { warnings: asList(warnings) });
+    }
+}
+// The ERROR/WARNING part of a service NACK for anything a handler threw. A
+// NackError gives its own items; anything else is StandardError
+// INTERNAL_ERROR with the error's message, as EventHandlerUtils.handleError
+// answers an unexpected exception. Legacy mode sends the pre-15.48 items
+// (no @type/STATUS_CODE, VALIDATION_ERROR by default) and no WARNING: it had
+// no warnings, so they go in ERROR, after the errors.
+export function nackPayload(error, legacy) {
+    if (error instanceof NackError) {
+        return legacy
+            ? { ERROR: [...error.inputs, ...error.warningInputs].map(toLegacyNackEntry) }
+            : { ERROR: error.errors, WARNING: error.warnings };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    if (legacy)
+        return { ERROR: [{ CODE: LEGACY_DEFAULT_CODE, TEXT: message }] };
+    return {
+        ERROR: [
+            toNackEntry({
+                '@type': 'StandardError',
+                CODE: ErrorCode.INTERNAL_ERROR,
+                TEXT: message || undefined,
+            }),
+        ],
+        WARNING: [],
+    };
+}
+// The payload for warnings a handler returned instead of throwing. Legacy
+// mode had no WARNING list, so they are sent as its {CODE, TEXT} errors.
+export function warningPayload(warnings, legacy) {
+    if (legacy)
+        return { ERROR: warnings.map(toLegacyNackEntry) };
+    return { ERROR: [], WARNING: warnings.map(toNackEntry) };
 }

package/dist/protocol/fieldTypes.d.ts

@@ -0,0 +1,10 @@
+export declare const BIGDECIMAL_PATTERN = "[0-9]+(\\.[0-9]+)?";
+export declare function jsonTypeOf(type: string): string;
+export declare function rangeOf(type: string): [number, number] | undefined;
+export declare function eventMetaTypeOf(type: string): string;
+export declare function titleCase(name: string): string;
+export declare function pascalCase(name: string): string;
+export declare function daoClassOf(table: string): string;
+export declare function viewEntityClassOf(view: string): string;
+export declare function enumClassOf(table: string | undefined, field: string, appName?: string): string;
+export declare function jvmClassOf(type: string, enumClass: () => string): string;

package/dist/protocol/fieldTypes.js

@@ -0,0 +1,107 @@
+// How the real server describes a Genesis field type on the wire: the JSON
+// type a value travels as, the JVM class its generated DAO property has, and
+// the names it derives from table and field names. Checked against GSF
+// 8.15.29 recordings (test/conformance/recordings/showcase-real/meta-*.json,
+// json-schema-*.json) and genesis-process's PALMetadataUtils.kt.
+// The JSON type each Genesis type travels as. Dates are epoch millis and
+// BigDecimals are strings, so a client must not read the Genesis type as the
+// JSON one.
+const JSON_TYPES = {
+    STRING: 'string',
+    ENUM: 'string',
+    INT: 'integer',
+    SHORT: 'integer',
+    LONG: 'integer',
+    DOUBLE: 'number',
+    BIGDECIMAL: 'string',
+    BOOLEAN: 'boolean',
+    DATE: 'integer',
+    DATETIME: 'integer',
+    NANO_TIMESTAMP: 'integer',
+    RAW: 'string',
+};
+// The JVM class of the generated DAO property, which the real server puts in
+// DESCRIPTION / description. foundation-forms recognises a date field by
+// 'org.joda.time.DateTime' (jsonforms/testers/isDate.ts).
+const JVM_CLASSES = {
+    STRING: 'kotlin.String',
+    INT: 'kotlin.Int',
+    SHORT: 'kotlin.Short',
+    LONG: 'kotlin.Long',
+    DOUBLE: 'kotlin.Double',
+    BIGDECIMAL: 'java.math.BigDecimal',
+    BOOLEAN: 'kotlin.Boolean',
+    DATE: 'org.joda.time.DateTime',
+    DATETIME: 'org.joda.time.DateTime',
+    NANO_TIMESTAMP: 'kotlin.Long',
+    RAW: 'kotlin.ByteArray',
+};
+// Value ranges the DAO's generated annotations carry, reported as MIN/MAX in
+// event META and minimum/maximum in event JSON schemas. LONG is bounded by
+// JavaScript's safe integers, not by Long.MAX_VALUE.
+const INT_MIN = -2147483648;
+const INT_MAX = 2147483647;
+const SHORT_MIN = -32768;
+const SHORT_MAX = 32767;
+const RANGES = {
+    INT: [INT_MIN, INT_MAX],
+    SHORT: [SHORT_MIN, SHORT_MAX],
+    LONG: [-Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    NANO_TIMESTAMP: [-Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    DOUBLE: [-Number.MAX_VALUE, Number.MAX_VALUE],
+};
+// What the real event schema puts on a BigDecimal property instead of a
+// genesisType.
+export const BIGDECIMAL_PATTERN = '[0-9]+(\\.[0-9]+)?';
+export function jsonTypeOf(type) {
+    return JSON_TYPES[type] ?? 'string';
+}
+export function rangeOf(type) {
+    return RANGES[type];
+}
+// TYPE in event META follows the JVM class, not the dictionary: a DATE column
+// is a DateTime property, so it is TYPE 'DATETIME' (GENESIS_TYPE says 'DATE').
+export function eventMetaTypeOf(type) {
+    if (type === 'DATE')
+        return 'DATETIME';
+    if (type === 'NANO_TIMESTAMP')
+        return 'LONG';
+    return type;
+}
+// 'COUNTERPARTY_ID' -> 'Counterparty Id', the TITLE the DAO generator gives.
+export function titleCase(name) {
+    return name
+        .split('_')
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+}
+// 'ALL_TYPES' -> 'AllTypes', the generated class name.
+export function pascalCase(name) {
+    return titleCase(name).replace(/ /g, '');
+}
+// The generated DAO class an event's DETAILS deserialize into.
+export function daoClassOf(table) {
+    return `global.genesis.gen.dao.${pascalCase(table)}`;
+}
+// The generated entity class of a view (ViewEntityGenerator.kt PACKAGE_NAME,
+// GSF v8.15.29): what a request server over the view names in
+// PARAMETRIC_TYPE.
+export function viewEntityClassOf(view) {
+    return `global.genesis.gen.view.entity.${pascalCase(view)}`;
+}
+// The generated enum class of an ENUM column.
+export function enumClassOf(table, field, appName) {
+    const segments = ['global.genesis.gen.dao.enums'];
+    if (appName)
+        segments.push(appName);
+    if (table)
+        segments.push(table.toLowerCase());
+    segments.push(pascalCase(field));
+    return segments.join('.');
+}
+export function jvmClassOf(type, enumClass) {
+    if (type === 'ENUM')
+        return enumClass();
+    return JVM_CLASSES[type] ?? 'kotlin.String';
+}

package/dist/protocol/gsfSchemas.d.ts

@@ -0,0 +1,9 @@
+import type { Row } from '../types.ts';
+export declare const QUERY_ROW = "global.genesis.message.core.dataserver.QueryRow";
+export declare function eventReplyMeta(): Row;
+export declare function eventReplySchema(): Row;
+export declare function eventInboundProperties(eventName: string, details: Row): Row;
+export declare const GENESIS_META_SCHEMA = "https://genesis.global/schema/v1/meta/genesis";
+export declare function dataLogonSchema(queryName: string): Row;
+export declare function dataLogonReplySchema(rowProperties: Row): Row;
+export declare const REQUEST_DETAILS_SCHEMA: Row;