@simtlix/simfinity-js-client 1.1.0 → 3.19.1

package/src/inputs.js

@@ -0,0 +1,106 @@
+const leaf = (ref) => { let current = ref; while (current?.ofType) current = current.ofType; return current; };
+const present = (value, options) => value !== undefined && (options.preserveEmpty || (value !== null && value !== ''));
+const versionValue = (value) => {
+  if (!Number.isSafeInteger(value) || value < 1) throw new Error('Record version must be a JSON integer from 1 to 9007199254740991');
+  return value;
+};
+const deltaType = (type) => type?.kind === 'INPUT_OBJECT' && type.fields.length > 0 && type.fields.every((field) => ['added', 'updated', 'deleted'].includes(field.name) && field.type.isList);
+
+export const cleanInputValue = (client, ref, value, options = {}, root = false) => {
+  if (ref.kind === 'NON_NULL') return cleanInputValue(client, ref.ofType, value, options, root);
+  if (value === undefined || value === null) return value;
+  if (ref.kind === 'LIST') return Array.isArray(value) ? value.map((item) => cleanInputValue(client, ref.ofType, item, options)) : cleanInputValue(client, ref.ofType, value, options);
+  if (ref.kind !== 'INPUT_OBJECT') {
+    if (ref.name === 'RecordVersion') return versionValue(value);
+    if (ref.kind === 'ENUM' || (options.preserveEmpty && value === '')) return value;
+    return client._coerceScalarValue(value, client._types.get(ref.name)?.baseScalar || ref.name);
+  }
+  const type = client._types.get(ref.name);
+  if (!type) throw new Error(`Unknown input type ${ref.name}`);
+  const input = typeof value === 'string' && type.fields.some((f) => f.name === 'id') ? { id: value } : value;
+  if (typeof input !== 'object' || Array.isArray(input)) throw new Error(`Expected input object ${ref.name}`);
+  const protectedVersion = type.fields.find((f) => f.name === 'version' && leaf(f.rawType)?.name === 'RecordVersion');
+  if (protectedVersion) versionValue(input.version);
+  const output = {};
+  for (const field of type.fields) {
+    const name = field.name;
+    if (input[name] === undefined || options.skipFields?.includes(name) || options.transientFields?.includes(name)) continue;
+    if (root && name === 'id' && options.mode !== 'update') continue;
+    if (name === '__typename' || name === '__status' || name === '__originalData') continue;
+    const target = client._types.get(leaf(field.rawType)?.name);
+    if (deltaType(target) && !options.includeCollections) continue;
+    if (field.type.isList && field.type.kind === 'INPUT_OBJECT' && !deltaType(type) && !options.includeCollections) continue;
+    let fieldValue = input[name];
+    if (deltaType(type) && name === 'deleted' && leaf(field.rawType)?.name === 'ID' && Array.isArray(fieldValue)) {
+      fieldValue = fieldValue.map((item) => item !== null && typeof item === 'object' ? item.id : item);
+    }
+    const cleaned = cleanInputValue(client, field.rawType, fieldValue, options);
+    if (present(cleaned, options)) output[name] = cleaned;
+  }
+  return output;
+};
+
+export const transformRootInput = (client, typeName, raw, options = {}) => {
+  const mode = options.mode || 'create';
+  const inputName = options.inputType || client._inputTypeName(typeName, mode === 'create' ? 'add' : 'update');
+  if (!inputName) return client._legacyTransformInput(typeName, raw, options);
+  const type = client._types.get(inputName);
+  if (!type || type.kind !== 'INPUT_OBJECT') throw new Error(`Unknown input type ${inputName}`);
+  if (mode === 'update' && raw.version !== undefined && !type.fields.some((f) => f.name === 'version')) throw new Error(`Input ${inputName} does not accept a version`);
+  return cleanInputValue(client, { name: inputName, kind: 'INPUT_OBJECT' }, raw, { ...options, mode }, true);
+};
+
+const collectionItemInput = (client, targetName, mode) => {
+  const kind = mode === 'create' ? 'add' : 'update';
+  const roots = [...client._mutations.values()].filter((operation) => ['add', 'update', 'stateTransition'].includes(operation.category));
+  const direct = roots.find((operation) => operation.typeName === targetName && operation.category === kind);
+  if (direct) return leaf(direct.args.find((arg) => arg.name === 'input')?.type)?.name;
+  const candidates = new Set(); const seen = new Set();
+  const visit = (entityName, inputName) => {
+    const key = `${entityName}:${inputName}`; if (seen.has(key)) return; seen.add(key);
+    const entity = client._types.get(entityName); const input = client._types.get(inputName);
+    if (!entity || input?.kind !== 'INPUT_OBJECT') return;
+    for (const field of input.fields) {
+      const output = entity.fields.find((item) => item.name === field.name);
+      if (output?.type.kind !== 'OBJECT') continue;
+      const nested = client._types.get(field.type.name);
+      if (output.type.isList && deltaType(nested)) {
+        for (const entry of nested.fields.filter((item) => ['added', 'updated'].includes(item.name))) {
+          if (output.type.name === targetName && entry.name === (mode === 'create' ? 'added' : 'updated')) candidates.add(entry.type.name);
+          visit(output.type.name, entry.type.name);
+        }
+      } else visit(output.type.name, field.type.name);
+    }
+  };
+  for (const root of roots) visit(root.typeName, leaf(root.args.find((arg) => arg.name === 'input')?.type)?.name);
+  if (candidates.size !== 1) throw new Error('Cannot choose a collection input unambiguously; supply inputType');
+  return [...candidates][0];
+};
+
+export const transformDelta = (client, typeName, delta, options = {}) => {
+  if (options.inputType) {
+    const input = client._types.get(options.inputType);
+    if (!deltaType(input)) throw new Error(`Not a collection delta input: ${options.inputType}`);
+    return cleanInputValue(client, { kind: 'INPUT_OBJECT', name: options.inputType }, delta, { ...options, includeCollections: true });
+  }
+  const result = {};
+  const clean = (item, mode) => {
+    const raw = { ...item };
+    delete raw.__status; delete raw.__originalData; delete raw.__typename;
+    if (options.connectionField) delete raw[options.connectionField];
+    if (mode === 'create' && typeof raw.id === 'string' && raw.id.startsWith('temp_')) delete raw.id;
+    return transformRootInput(client, typeName, raw, { ...options, mode, inputType: collectionItemInput(client, typeName, mode), includeCollections: true });
+  };
+  if (delta.added?.length) result.added = delta.added.map((item) => clean(item, 'create'));
+  if (delta.updated?.length) result.updated = delta.updated.map((item) => clean(item, 'update'));
+  if (delta.deleted?.length) {
+    const protectedDelete = client._types.get(typeName)?.fields.some((field) => field.name === 'version' && field.type.name === 'RecordVersion');
+    result.deleted = delta.deleted.map((item) => {
+      if (item === null) return null;
+      if (!protectedDelete) return typeof item === 'object' ? item.id : item;
+      if (typeof item !== 'object') throw new Error('Protected collection deletion requires id and version');
+      return { id: item.id, version: versionValue(item.version) };
+    });
+  }
+  return result;
+};

package/src/metadata.js

@@ -0,0 +1,104 @@
+// This module reads wire metadata only; it deliberately imports no server code.
+const kinds = { entity: 'OBJECT', object: 'OBJECT', input: 'INPUT_OBJECT', enum: 'ENUM', scalar: 'SCALAR', interface: 'INTERFACE', union: 'UNION' };
+const namePattern = /^[_A-Za-z][_0-9A-Za-z]*$/;
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const invalid = (detail) => { throw new Error(`Invalid client descriptor: ${detail}`); };
+
+export const parseTypeReference = (text, types) => {
+  if (typeof text !== 'string' || text.length > 1024) invalid('invalid type reference');
+  let position = 0;
+  const read = (depth = 0) => {
+    if (depth > 64) invalid('type reference nesting exceeds 64');
+    let ref;
+    if (text[position] === '[') {
+      position++;
+      ref = { kind: 'LIST', ofType: read(depth + 1) };
+      if (text[position++] !== ']') invalid(`invalid type reference ${text}`);
+    } else {
+      const name = text.slice(position).match(/^[_A-Za-z][_0-9A-Za-z]*/)?.[0];
+      if (!name || !Object.hasOwn(types, name)) invalid(`unknown type ${name || text}`);
+      position += name.length;
+      ref = { kind: kinds[types[name].kind], name };
+    }
+    if (text[position] === '!') { position++; ref = { kind: 'NON_NULL', ofType: ref }; }
+    return ref;
+  };
+  const result = read();
+  if (position !== text.length) invalid(`invalid type reference ${text}`);
+  return result;
+};
+
+export const normalizeDescriptor = (document) => {
+  if (!record(document) || document.formatVersion !== 1) invalid('unsupported format version (expected 1)');
+  if (!record(document.types) || !record(document.operations) || !record(document.roots)) invalid('types, roots and operations are required');
+  const descriptor = JSON.parse(JSON.stringify(document));
+  const types = descriptor.types;
+  for (const [name, type] of Object.entries(types)) {
+    if (!namePattern.test(name) || !record(type) || !Object.hasOwn(kinds, type.kind)) invalid(`invalid type ${name}`);
+  }
+  const reference = (text) => parseTypeReference(text, types);
+  const input = (arg) => {
+    if (!record(arg) || !namePattern.test(arg.name)) invalid('invalid argument or input field');
+    return { ...arg, type: reference(arg.type) };
+  };
+  const normalized = Object.entries(types).map(([name, type]) => ({
+    name, kind: kinds[type.kind], description: type.description, isOneOf: type.isOneOf,
+    baseScalar: type.baseScalar, possibleTypes: type.possibleTypes, interfaces: type.interfaces,
+    enumValues: type.values || [],
+    ...(type.kind === 'input' ? { inputFields: (type.fields || []).map(input) } : { fields: (type.fields || []).map((field) => ({
+      ...input(field), args: (field.args || []).map(input),
+      extensions: { relation: field.relation || null, readOnly: field.readOnly, stateMachine: field.stateMachine,
+        ...(field.virtual ? { virtual: field.virtual } : {}), ...(field.queryable !== undefined ? { queryable: field.queryable } : {}),
+        ...(field.rootInputUsage ? { rootInputUsage: field.rootInputUsage } : {}) },
+    })) }),
+  }));
+  for (const root of ['query', 'mutation']) {
+    if (!record(descriptor.operations[root])) invalid(`invalid ${root} operations`);
+    const entries = Object.entries(descriptor.operations[root]);
+    const rootName = descriptor.roots[root];
+    if (rootName !== null && (typeof rootName !== 'string' || !namePattern.test(rootName))) invalid(`invalid ${root} root`);
+    if (entries.length && !rootName) invalid(`missing ${root} root`);
+    const fields = entries.map(([name, operation]) => {
+      if (!namePattern.test(name) || !record(operation) || !Array.isArray(operation.args)) invalid(`invalid operation ${name}`);
+      if (operation.type !== null && (!Object.hasOwn(types, operation.type))) invalid(`unknown operation type ${operation.type}`);
+      return { name, description: operation.description, type: reference(operation.returns), args: operation.args.map(input) };
+    });
+    if (rootName) {
+      const existing = normalized.find((type) => type.name === rootName);
+      if (existing) existing.fields = fields;
+      else normalized.push({ name: rootName, kind: 'OBJECT', fields });
+    }
+  }
+  for (const [name, type] of Object.entries(types)) {
+    for (const [kind, endpoint] of Object.entries(type.endpoints || {})) {
+      const root = ['get', 'list', 'aggregate'].includes(kind) ? 'query' : 'mutation';
+      if (!Object.hasOwn(descriptor.operations[root], endpoint) || descriptor.operations[root][endpoint].type !== name) invalid(`invalid endpoint ${name}.${kind}`);
+    }
+    if (type.inputs !== undefined && !record(type.inputs)) invalid(`invalid inputs for ${name}`);
+    for (const kind of ['add', 'update']) {
+      const inputName = type.inputs?.[kind];
+      if (inputName === undefined) continue;
+      if (typeof inputName !== 'string' || !Object.hasOwn(types, inputName) || types[inputName].kind !== 'input') invalid(`invalid input ${name}.${kind}: ${inputName}`);
+      const endpoint = type.endpoints?.[kind];
+      if (endpoint === undefined) continue; // Embedded/nested inputs need not have root endpoints.
+      const operation = descriptor.operations.mutation[endpoint];
+      const argument = operation?.args.find((arg) => arg.name === 'input');
+      if (!argument) invalid(`missing input operation ${name}.${kind}`);
+      let ref = reference(argument.type); while (ref.ofType) ref = ref.ofType;
+      if (ref.name !== inputName) invalid(`input ${name}.${kind} differs from its operation`);
+    }
+  }
+  return { descriptor, schema: { types: normalized, queryType: descriptor.roots.query ? { name: descriptor.roots.query } : null,
+    mutationType: descriptor.roots.mutation ? { name: descriptor.roots.mutation } : null } };
+};
+
+const typeRefSelection = (depth) => depth ? `kind name ofType { ${typeRefSelection(depth - 1)} }` : 'kind name';
+export const introspectionQuery = (extended = true) => {
+  const ref = typeRefSelection(16);
+  const argument = `name description defaultValue type { ${ref} }`;
+  return `query IntrospectionQuery { __schema { queryType { name } mutationType { name } types {
+    name kind description fields(includeDeprecated: true) { name description type { ${ref} } args { ${argument} }
+      ${extended ? 'extensions { relation { displayField embedded connectionField } stateMachine readOnly }' : ''}
+    } inputFields { ${argument} } enumValues(includeDeprecated: true) { name } possibleTypes { name } interfaces { name }
+  } } }`;
+};

package/src/selection.js

@@ -0,0 +1,88 @@
+const namePattern = /^[_A-Za-z][_0-9A-Za-z]*$/;
+const tokensOf = (text) => {
+  const tokens = []; let index = 0;
+  const token = /(?:\s+|#[^\n\r]*|,|\.\.\.|"""[\s\S]*?"""|"(?:\\.|[^"\\])*"|[_A-Za-z][_0-9A-Za-z]*|-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?|[!$():=@[\]{}])/y;
+  while (index < text.length) {
+    token.lastIndex = index; const match = token.exec(text);
+    if (!match) throw new Error(`Invalid field selection at position ${index}`);
+    index = token.lastIndex;
+    if (!/^(?:\s|#|,)/.test(match[0])) tokens.push(match[0]);
+  }
+  return tokens;
+};
+const node = (name, alias = null) => ({ name, alias, suffix: '', selection: new SelectionTree() });
+
+export class SelectionTree {
+  constructor() { this.nodes = new Map(); }
+  addScalars(fields) { for (const name of fields.trim().split(/\s+/)) { if (!name) continue; if (!namePattern.test(name)) throw new Error(`Invalid field ${name}`); if (!this.nodes.has(name)) this.nodes.set(name, node(name)); } }
+  addSelection(text) {
+    const tokens = tokensOf(text); let index = 0;
+    const name = () => { const value = tokens[index++]; if (!namePattern.test(value || '')) throw new Error('Invalid field selection name'); return value; };
+    const balanced = () => {
+      const output = []; let depth = 0;
+      do { const value = tokens[index++]; if (value === undefined) throw new Error('Unclosed selection arguments'); output.push(value); if (value === '(') depth++; if (value === ')') depth--; } while (depth);
+      return output.join(' ');
+    };
+    const read = (tree, nested = false) => {
+      while (index < tokens.length && tokens[index] !== '}') {
+        let field;
+        if (tokens[index] === '...') {
+          index++; const fragment = name();
+          field = node(fragment === 'on' ? `... on ${name()}` : `...${fragment}`);
+        } else {
+          const first = name();
+          field = tokens[index] === ':' ? (index++, node(name(), first)) : node(first);
+        }
+        if (tokens[index] === '(') field.suffix += balanced();
+        while (tokens[index] === '@') { index++; field.suffix += ` @${name()}`; if (tokens[index] === '(') field.suffix += balanced(); }
+        if (tokens[index] === '{') { index++; read(field.selection, true); }
+        const key = field.alias || field.name;
+        tree.mergeNode(key, field);
+      }
+      if (nested && tokens[index++] !== '}') throw new Error('Unclosed field selection');
+    };
+    read(this);
+    if (index !== tokens.length) throw new Error('Unexpected closing selection brace');
+  }
+  mergeNode(key, field) {
+    const previous = this.nodes.get(key);
+    if (!previous) { this.nodes.set(key, field); return; }
+    if (previous.name !== field.name || previous.suffix !== field.suffix) throw new Error(`Conflicting selections for ${key}`);
+    for (const [child, value] of field.selection.nodes) previous.selection.mergeNode(child, value);
+  }
+  addNested(path, fields) {
+    let tree = this;
+    for (const part of path.split('.')) {
+      if (!namePattern.test(part)) throw new Error(`Invalid collection path ${path}`);
+      if (!tree.nodes.has(part)) tree.nodes.set(part, node(part));
+      tree = tree.nodes.get(part).selection;
+    }
+    tree.addSelection(fields);
+  }
+  isEmpty() { return this.nodes.size === 0; }
+  serialize(context, typeName, prefix = '') {
+    const output = [];
+    for (const field of this.nodes.values()) {
+      const key = field.alias || field.name; const path = field.name.startsWith('...') ? prefix : prefix ? `${prefix}.${key}` : key;
+      const info = context?.types.get(typeName)?.fields.find((f) => f.name === field.name);
+      let suffix = field.suffix;
+      if (context?.arguments.has(path)) {
+        if (!info?.type.isList || info.type.kind !== 'OBJECT') throw new Error(`Not a collection field: ${path}`);
+        if (suffix) throw new Error(`Arguments already provided for ${path}`);
+        context.used.add(path);
+        const provided = context.arguments.get(path); const args = [];
+        for (const [name, value] of Object.entries(provided)) {
+          if (value === undefined) continue;
+          const arg = info.args.find((a) => a.name === name);
+          if (!arg) throw new Error(`Unknown collection argument ${path}.${name}`);
+          args.push(`${name}: $${context.variable(arg.type, value)}`);
+        }
+        if (args.length) suffix = `(${args.join(', ')})`;
+      }
+      const fragmentType = field.name.startsWith('... on ') ? field.name.slice(7) : typeName;
+      const children = field.selection.serialize(context, info?.type.name || fragmentType, path);
+      output.push(`${field.alias ? `${field.alias}: ` : ''}${field.name}${suffix}${children ? ` { ${children} }` : ''}`);
+    }
+    return output.join(' ');
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,91 @@
+/** HTTP-only browser client. No server or Node ambient types are required. */
+export interface TypeReference { readonly kind: string; readonly name?: string | null; readonly ofType?: TypeReference | null; }
+export interface UnwrappedType { name: string; kind: string; isList: boolean; isNonNull: boolean; }
+export interface InputValue { readonly name: string; readonly type: string; readonly description?: string | null; readonly hasDefault?: boolean; readonly defaultValue?: string; }
+export interface DescriptorOperation { readonly operation: 'get' | 'list' | 'aggregate' | 'add' | 'update' | 'delete' | 'transition' | 'transaction' | 'customQuery' | 'customMutation'; readonly type: string | null; readonly args: readonly InputValue[]; readonly returns: string; readonly description?: string | null; readonly view?: string; readonly action?: string; readonly from?: string | null; readonly to?: string | null; }
+export interface DescriptorField extends InputValue { readonly kind?: string; readonly readOnly?: boolean; readonly stateMachine?: boolean; readonly queryable?: boolean; readonly unique?: boolean; readonly relation?: { readonly target: string; readonly embedded: boolean; readonly connectionField: string | null; readonly displayField: string | null; readonly inverseField?: string | null }; readonly args?: readonly InputValue[]; readonly virtual?: { readonly mcp: 'tool' | 'select' | false }; readonly rootInputUsage?: Readonly<{ add?: 'required' | 'optional'; update?: 'required' | 'optional' }>; readonly deprecationReason?: string | null; }
+export interface DescriptorStateMachine { readonly field: 'state'; readonly enum: string; readonly initialState: string | null; readonly states: readonly string[]; readonly actions: readonly { readonly name: string; readonly mutation: string; readonly description: string | null; readonly from: string | null; readonly to: string | null }[]; }
+export interface DescriptorType { readonly kind: 'entity' | 'object' | 'interface' | 'union' | 'input' | 'enum' | 'scalar'; readonly description?: string | null; readonly stateMachine?: DescriptorStateMachine | null; readonly fields?: readonly DescriptorField[]; readonly values?: readonly { readonly name: string; readonly description?: string | null; readonly deprecationReason?: string | null }[]; readonly endpoints?: Readonly<Partial<Record<'get' | 'list' | 'aggregate' | 'add' | 'update' | 'delete', string>>>; readonly inputs?: Readonly<{ add?: string; update?: string }>; readonly baseScalar?: string | null; readonly isOneOf?: boolean; readonly possibleTypes?: readonly string[]; readonly interfaces?: readonly string[]; }
+export interface ClientDescriptorDocument { readonly formatVersion: 1; readonly generator?: { readonly name: string; readonly version: string }; readonly roots: { readonly query: string | null; readonly mutation: string | null }; readonly types: Readonly<Record<string, DescriptorType>>; readonly operations: { readonly query: Readonly<Record<string, DescriptorOperation>>; readonly mutation: Readonly<Record<string, DescriptorOperation>> }; }
+export interface ClientRequestInit { method?: string; headers?: Record<string, string>; body?: string; }
+export interface ClientResponse { readonly ok: boolean; readonly status: number; json(): Promise<unknown>; }
+export type ClientFetch = (url: string, options?: ClientRequestInit) => Promise<ClientResponse>;
+export interface SimfinityClientOptions { prepareHeaders?: (headers: Record<string, string>) => unknown; fetch?: ClientFetch; descriptor?: ClientDescriptorDocument; descriptorEndpoint?: string; introspection?: 'extended' | 'standard'; }
+export interface FieldExtensions { relation?: { displayField?: string | null; embedded?: boolean | null; connectionField?: string | null; target?: string; inverseField?: string | null } | null; stateMachine?: boolean | null; readOnly?: boolean | null; virtual?: { mcp: 'tool' | 'select' | false }; queryable?: boolean; rootInputUsage?: { add?: 'required' | 'optional'; update?: 'required' | 'optional' }; }
+export interface TypeField { name: string; type: UnwrappedType; rawType: TypeReference; args: ArgumentInfo[]; extensions: FieldExtensions | null; hasDefault?: boolean; defaultValue?: unknown; }
+export interface TypeInfo { name: string; kind: string; fields: TypeField[]; enumValues: string[]; baseScalar?: string | null; isOneOf?: boolean; possibleTypes?: readonly string[]; interfaces?: readonly string[]; }
+export interface ArgumentInfo { name: string; type: TypeReference; hasDefault?: boolean; defaultValue?: unknown; }
+export interface OperationInfo { name: string; args: ArgumentInfo[]; returnType: UnwrappedType; rawReturnType: TypeReference; category?: string; typeName?: string | null; view?: string; action?: string; }
+export interface SelectionSetResult { selection: string; columns: string[]; sortFieldByColumn: Record<string, string>; fieldTypeByColumn: Record<string, string>; }
+export interface QueryNamesForType { pluralQueryName: string | null; singularQueryName: string | null; aggregateQueryName: string | null; }
+export interface Transition { action: string; mutationName: string; }
+export interface FilterTerm { path?: string; operator?: string; value?: unknown; value2?: unknown; valuePath?: string | null; }
+export interface FilterCondition extends FilterTerm { field: string; }
+export interface QuantifiedGroup extends FilterGroup { path: string; }
+export interface FilterGroup { conditions?: readonly FilterCondition[]; AND?: readonly FilterGroup[]; OR?: readonly FilterGroup[]; ANY?: readonly QuantifiedGroup[]; ALL?: readonly QuantifiedGroup[]; NONE?: readonly QuantifiedGroup[]; }
+export interface FieldFilter extends FilterTerm { terms?: readonly FilterTerm[]; quantifier?: 'ANY' | 'ALL' | 'NONE'; }
+export interface ExecWithMetaResult<T = unknown> { data: T; extensions: Record<string, unknown> | null; }
+export interface QueryBuilder<T = Record<string, unknown>> {
+  where(field: string, operator: string, value?: unknown, value2?: unknown): this;
+  where(field: string, terms: readonly FilterTerm[]): this;
+  where(field: string, filter: FieldFilter): this;
+  filter(group: FilterGroup): this; or(groups: readonly FilterGroup[]): this; and(groups: readonly FilterGroup[]): this;
+  joinCollection(path: string, fields: string, filter?: readonly FilterTerm[]): this;
+  joinObject(path: string, fields: string): this; collectionArgs(path: string, args: Record<string, unknown>): this;
+  fields(selection: string): this; page(page: number, size: number, count?: boolean): this;
+  sort(field: string, order: 'ASC' | 'DESC'): this; clearSort(): this; autoSelect(): this;
+  exec(): Promise<(T[] & { __extensions?: Record<string, unknown> }) | null>;
+  execWithMeta(): Promise<ExecWithMetaResult<T[] | null>>;
+}
+export interface AggregateBuilder<T = Record<string, unknown>> {
+  groupBy(field: string): this; fact(operation: string, factName: string, path?: string): this;
+  where(field: string, operator: string, value?: unknown, value2?: unknown): this;
+  where(field: string, terms: readonly FilterTerm[]): this; where(field: string, filter: FieldFilter): this;
+  filter(group: FilterGroup): this; or(groups: readonly FilterGroup[]): this; and(groups: readonly FilterGroup[]): this;
+  page(page: number, size: number, count?: boolean): this; sort(field: string, order: 'ASC' | 'DESC'): this; exec(): Promise<T[]>;
+}
+export interface TransformInputOptions { mode?: 'create' | 'update'; skipFields?: readonly string[]; transientFields?: readonly string[]; preserveEmpty?: boolean; includeCollections?: boolean; inputType?: string; }
+export interface CollectionDelta { added?: readonly Record<string, unknown>[]; updated?: readonly Record<string, unknown>[]; deleted?: readonly (string | Record<string, unknown> | null)[]; }
+export interface CollectionDeltaOptions extends TransformInputOptions { connectionField?: string | null; }
+export interface MutationOptions extends TransformInputOptions { transform?: boolean; }
+export interface GraphQLErrorData { message: string; extensions?: Record<string, unknown>; path?: readonly (string | number)[]; locations?: readonly { line: number; column: number }[]; }
+export interface GraphQLResponse<T = Record<string, unknown>> { data?: T | null; errors?: GraphQLErrorData[]; extensions?: Record<string, unknown>; }
+export default class SimfinityClient {
+  constructor(endpoint: string, options?: SimfinityClientOptions);
+  init(): Promise<void>; getDescriptor(): ClientDescriptorDocument | null;
+  find<T = Record<string, unknown>>(typeName: string): QueryBuilder<T>;
+  findView<T = Record<string, unknown>>(name: string, params?: Record<string, unknown>): QueryBuilder<T>;
+  getViews(typeName?: string): OperationInfo[];
+  aggregate<T = Record<string, unknown>>(typeName: string): AggregateBuilder<T>;
+  query<T = unknown>(name: string, args?: Record<string, unknown>, fields?: string): Promise<T>;
+  findByParent<T = Record<string, unknown>>(typeName: string, connectionField: string, parentId: string): QueryBuilder<T>;
+  search<T = Record<string, unknown>>(typeName: string, searchTerm: string, options?: { displayField?: string | null; page?: number; size?: number }): Promise<T[] | null>;
+  getById<T = Record<string, unknown>>(typeName: string, id: string, fields?: string): Promise<T | null>;
+  add<T = Record<string, unknown>>(typeName: string, input: Record<string, unknown>, fields?: string, options?: MutationOptions): Promise<T>;
+  update<T = Record<string, unknown>>(typeName: string, id: string, input: Record<string, unknown>, fields?: string, options?: MutationOptions): Promise<T | null>;
+  delete<T = Record<string, unknown>>(typeName: string, id: string, fields?: string, options?: { version?: number }): Promise<T | null>;
+  transition<T = Record<string, unknown>>(typeName: string, action: string, id: string, inputOrFields?: Record<string, unknown> | string, fields?: string): Promise<T | null>;
+  transaction<T = Record<string, unknown>>(operations: readonly Record<string, unknown>[], fields?: string, options?: { name?: string }): Promise<T[] | null>;
+  customMutation<T = unknown>(name: string, args?: Record<string, unknown>, fields?: string): Promise<T>;
+  execute<T = Record<string, unknown>>(query: string, variables?: Record<string, unknown>): Promise<GraphQLResponse<T>>;
+  getTypes(): Record<string, TypeInfo>; getQueries(): Record<string, OperationInfo>; getMutations(): Record<string, OperationInfo>;
+  buildSelectionSet(typeName: string): SelectionSetResult;
+  getFieldExtensions(typeName: string, fieldName: string): FieldExtensions | null;
+  getDisplayField(typeName: string, fieldName: string): string | null;
+  isEmbeddedField(typeName: string, fieldName: string): boolean;
+  getConnectionField(typeName: string, fieldName: string): string | null;
+  isStateMachineField(typeName: string, fieldName: string): boolean;
+  isReadOnlyField(typeName: string, fieldName: string): boolean;
+  getEnumValues(typeName: string): string[]; getFieldsOfType(typeName: string): TypeField[];
+  getDescriptionFieldType(typeName: string, descriptionField: string): string;
+  getTypeNameForQuery(queryName: string): string | null;
+  getPluralQueryName(typeName: string): string | null; getSingularQueryName(typeName: string): string | null;
+  getListEntityNames(): string[]; getListEntityNamesOfType(typeName: string): string[];
+  getQueryNamesForType(typeName: string): QueryNamesForType;
+  getActualScalarType(scalarName: string): string | null; isNumericScalar(scalarName: string): boolean;
+  isBooleanScalar(scalarName: string): boolean; isDateTimeScalar(scalarName: string): boolean;
+  getStateMachineFields(typeName: string): string[]; getAvailableTransitions(typeName: string): Transition[];
+  transformInput(typeName: string, rawInput: Record<string, unknown>, options?: TransformInputOptions): Record<string, unknown>;
+  transformCollectionDelta(typeName: string, delta: CollectionDelta, options?: CollectionDeltaOptions): Record<string, unknown>;
+  static condition(field: string, operator: string, value?: unknown, path?: string): FilterGroup;
+}

package/.claude/worktrees/flamboyant-cartwright/.claude/settings.local.json

@@ -1,18 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(export GIT_EXEC_PATH=/opt/homebrew/libexec/git-core)",
-      "Bash(git --version)",
-      "Bash(/opt/homebrew/bin/git status:*)",
-      "Bash(/usr/local/bin/git status:*)",
-      "Read(//opt/homebrew/bin/**)",
-      "Bash(GIT=/opt/homebrew/bin/git)",
-      "Bash($GIT diff:*)",
-      "Bash($GIT log:*)",
-      "Bash($GIT add:*)",
-      "Bash($GIT commit:*)",
-      "Bash($GIT checkout:*)",
-      "Bash($GIT merge:*)"
-    ]
-  }
-}