@genesislcap/mock-server 15.51.1 → 15.53.0

package/src/handlers/resourceAuth.ts

@@ -1,3 +1,4 @@
+import { projectRow } from '../db/schema.ts';
 import type { Connection } from '../protocol/connection.ts';
 import type { ResourceAuthDef, RequestingUser, Row } from '../types.ts';
 
@@ -35,3 +36,20 @@ export function applyResourceAuth(
   }
   return result;
 }
+
+// One dataserver row as this user sees it: undefined when rowFilter rejects
+// it, else only the query's columns (projectRow: fieldNames from
+// queryFieldNames) minus the hidden ones. rowFilter sees the whole row, so a
+// filter may read a column the query doesn't expose.
+export function permittedQueryRow(
+  row: Row,
+  auth: ResourceAuthDef | undefined,
+  user: RequestingUser,
+  fieldNames: string[] | undefined,
+): Row | undefined {
+  if (auth?.rowFilter && !auth.rowFilter(row, user)) return undefined;
+  const projected = projectRow(row, fieldNames);
+  const hidden = hiddenFields(auth, user);
+  if (hidden.size === 0) return projected;
+  return Object.fromEntries(Object.entries(projected).filter(([field]) => !hidden.has(field)));
+}

package/src/handlers/resources.ts

@@ -1,3 +1,4 @@
+import { crudEventNames } from '../db/schema.ts';
 import type { Connection } from '../protocol/connection.ts';
 import { MESSAGE_TYPE } from '../protocol/messageTypes.ts';
 import type { GenesisMessage, MockServerConfig, ResourceItem } from '../types.ts';
@@ -19,6 +20,8 @@ function deriveResources(config: MockServerConfig): ResourceItem[] {
   }
   const eventNames = new Set([
     ...Object.keys(config.eventHandlers ?? {}),
+    // The generic CRUD events tables register through TableDef.events.
+    ...crudEventNames(config),
     // Events served only by eventSchemas + defaultEventHandler still need to
     // be discoverable, or the client-side resource gate blocks them before
     // the commit is ever sent.

package/src/index.ts

@@ -1,7 +1,17 @@
 export { createMockServer, type MockServer } from './server.ts';
 export { launchStack, type LaunchStackOptions, type LaunchedStack } from './launch.ts';
 export { Store } from './db/store.ts';
-export { NackError, type NackErrorInput, type NackErrorEntry } from './protocol/errors.ts';
+export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './db/identity.ts';
+export {
+  ErrorCode,
+  NackError,
+  statusCodeFor,
+  type ErrorCodeName,
+  type GenesisErrorType,
+  type NackErrorEntry,
+  type NackErrorInput,
+  type NackErrorOptions,
+} from './protocol/errors.ts';
 export { compileCriteria, filterByCriteria, type Predicate } from './db/criteria.ts';
 export type {
   AntiJoinDef,
@@ -9,14 +19,19 @@ export type {
   AuthUser,
   BroadcastFn,
   BroadcastTableChangeFn,
+  CrudEventVerb,
   EventHandler,
   EventHandlerCtx,
   EventHandlerResult,
   EventSchemaOverride,
   FidelityMode,
+  FieldDef,
   FieldMetadata,
+  GeneratedFieldDef,
+  GenesisFieldType,
   GenesisMessage,
   HttpRouteDef,
+  IndexDef,
   JoinDef,
   MockServerConfig,
   OnMessageCtx,
@@ -28,6 +43,7 @@ export type {
   ResourceAuthDef,
   ResourceItem,
   Row,
+  SequenceFormat,
   SocketLike,
   SsoIdentityProvider,
   TableDef,

package/src/protocol/connection.ts

@@ -6,8 +6,9 @@ const WS_OPEN = 1;
 
 export interface Subscription {
   resourceName: string;
-  // Computes the DETAILS.ROW_REF value for a pushed row (single pk value, or
-  // the joined composite key) — bound to Store.getRowRef at subscribe time.
+  // Computes the DETAILS.ROW_REF value for a pushed row (its RECORD_ID as a
+  // string; in legacy mode the pk value or joined composite key) — see
+  // rowRefFor in protocol/rowUpdate.ts.
   getRowRef: (row: Row) => unknown;
   predicate: Predicate;
   // SEQUENCE_ID of the last QUERY_UPDATE sent on this subscription (the
@@ -27,6 +28,13 @@ export interface Subscription {
   held?: Set<string>;
   maxRows?: number;
   maxView?: number;
+  // The columns this subscription's rows carry (the query's fields block or
+  // declared columns, narrowed by DETAILS.FIELDS); undefined: rows as stored.
+  fieldNames?: string[];
+  // Set under ORDER_BY: offered every live INSERT (stamped, and the raw
+  // row). Returns true when the row sorts among the rows still waiting for
+  // MORE_ROWS, and so was queued there in order instead of being pushed.
+  queueInsert?: (key: string, stamped: Row, row: Row) => boolean;
 }
 
 // Wraps one WebSocket client connection: auth state and its live DATA_LOGON

package/src/protocol/errors.ts

@@ -1,32 +1,380 @@
+// 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],
+} as const satisfies Record<string, readonly [string, string]>;
+
+export type ErrorCodeName = keyof typeof ERROR_CODES;
+
+// 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]),
+) as { readonly [Name in ErrorCodeName]: Name };
+
+// Codes that aren't in ErrorCode.kt but do appear in platform NACKs.
+const EXTRA_STATUSES: Record<string, string> = {
+  INCORRECT_CREDENTIALS: UNAUTHORIZED, // platform-auth's LoginError
+};
+
+function knownCode(code: string): readonly [string, string] | undefined {
+  return Object.hasOwn(ERROR_CODES, code) ? ERROR_CODES[code as ErrorCodeName] : 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: string): string {
+  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: string): string | undefined {
+  return knownCode(code)?.[0];
+}
+
+export type GenesisErrorType = 'StandardError' | 'FieldError' | 'TableStandardError' | 'LoginError';
+
+// What a handler throws (inside a NackError) or returns as a warning. Keys
+// are accepted in either case. Without '@type', the class is inferred: TABLE
+// makes a TableStandardError, FIELD (or PATH) a FieldError, anything else a
+// StandardError. Without CODE, a FieldError is VALIDATION_ERROR and anything
+// else REQUEST_FAILED — what a failed GPAL require() sends (an
+// IllegalArgumentException; EventHandlerUtils.handleError). GPAL's
+// nack("text") is INTERNAL_ERROR instead: see NackError.nack.
 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;
 }
 
+// One wire error item. '@type' and STATUS_CODE are always present by default;
+// they are optional here only because fidelity: 'legacy' sends the pre-15.48
+// {CODE, TEXT, FIELD?} items.
 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;
+}
+
+const LEGACY_DEFAULT_CODE = 'VALIDATION_ERROR';
+const UNKNOWN_TEXT = 'Unknown error';
+
+function inferType(input: NackErrorInput): GenesisErrorType {
+  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: NackErrorInput): NackErrorEntry {
+  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: NackErrorEntry = {
+    '@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: NackErrorInput): NackErrorEntry {
+  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 } : {}),
+  };
 }
 
-// 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.
+function asList(inputs: string | NackErrorInput | NackErrorInput[] | undefined): NackErrorInput[] {
+  if (inputs === undefined) return [];
+  if (typeof inputs === 'string') return [{ TEXT: inputs }];
+  return Array.isArray(inputs) ? inputs : [inputs];
+}
+
+export interface NackErrorOptions {
+  // Sent in the NACK's WARNING list. (Acting on IGNORE_WARNINGS is a later
+  // item; for now a warning always fails the event.)
+  warnings?: NackErrorInput | NackErrorInput[];
+}
+
+// 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 {
   readonly errors: NackErrorEntry[];
+  readonly warnings: NackErrorEntry[];
+  readonly inputs: readonly NackErrorInput[];
+  readonly warningInputs: readonly NackErrorInput[];
+
+  constructor(errors: string | NackErrorInput | NackErrorInput[], options: NackErrorOptions = {}) {
+    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;
+  }
 
-  constructor(errors: NackErrorInput | NackErrorInput[]) {
-    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 } : {}),
-    }));
+  // 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: string,
+    text: string,
+    path: string | null = null,
+    code: string = ErrorCode.VALIDATION_ERROR,
+  ): NackError {
+    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: string, text?: string): NackError {
+    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: string, index: string, value: unknown, text?: string): NackError {
+    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: string, index = '', text?: string): NackError {
+    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: string): NackError {
+    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: string | NackErrorInput | NackErrorInput[]): NackError {
+    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: unknown,
+  legacy: boolean,
+): { ERROR: NackErrorEntry[]; WARNING?: NackErrorEntry[] } {
+  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: NackErrorInput[],
+  legacy: boolean,
+): { ERROR: NackErrorEntry[]; WARNING?: NackErrorEntry[] } {
+  if (legacy) return { ERROR: warnings.map(toLegacyNackEntry) };
+  return { ERROR: [], WARNING: warnings.map(toNackEntry) };
 }

package/src/protocol/fieldTypes.ts

@@ -0,0 +1,115 @@
+// 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: Record<string, string> = {
+  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: Record<string, string> = {
+  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: Record<string, [number, number]> = {
+  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: string): string {
+  return JSON_TYPES[type] ?? 'string';
+}
+
+export function rangeOf(type: string): [number, number] | undefined {
+  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: string): string {
+  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: string): string {
+  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: string): string {
+  return titleCase(name).replace(/ /g, '');
+}
+
+// The generated DAO class an event's DETAILS deserialize into.
+export function daoClassOf(table: string): string {
+  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: string): string {
+  return `global.genesis.gen.view.entity.${pascalCase(view)}`;
+}
+
+// The generated enum class of an ENUM column.
+export function enumClassOf(table: string | undefined, field: string, appName?: string): string {
+  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: string, enumClass: () => string): string {
+  if (type === 'ENUM') return enumClass();
+  return JVM_CLASSES[type] ?? 'kotlin.String';
+}