@registrystack/client 0.38.0 → 0.40.0

package/scheduling/client.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const { types: { isProxy } } = require('node:util');
+const native = require('./index');
+
+const MAX_JSON_DEPTH = 64;
+const MAX_JSON_NODES = 20_000;
+const MAX_JSON_STRING_BYTES = 1024 * 1024;
+
+class SchedulingClientError extends Error {
+  constructor(envelope) {
+    super(envelope.message);
+    this.name = 'SchedulingClientError';
+    this.kind = envelope.kind;
+    this.outcomeUnknown = envelope.outcomeUnknown === true;
+    for (const field of ['code', 'title', 'detail', 'status', 'traceId', 'transportKind', 'protocolFailure']) {
+      if (envelope[field] !== undefined && envelope[field] !== null) this[field] = envelope[field];
+    }
+  }
+}
+
+const FALLBACK_MESSAGES = {
+  configuration: 'Scheduling client configuration is invalid',
+  'invalid-request': 'Scheduling client arguments are invalid',
+  protocol: 'Registry Scheduling client failed',
+};
+
+function normalized(error, fallbackKind) {
+  if (error instanceof SchedulingClientError) return error;
+  if (error instanceof Error && typeof error.message === 'string') {
+    try {
+      const envelope = JSON.parse(error.message);
+      if (envelope && typeof envelope.kind === 'string') return new SchedulingClientError(envelope);
+    } catch {
+      // napi argument conversion errors have no mapped envelope.
+    }
+  }
+  if (fallbackKind) {
+    return new SchedulingClientError({
+      kind: fallbackKind,
+      message: FALLBACK_MESSAGES[fallbackKind],
+      // A rejection after the native client took the call may follow an
+      // exchange, so it leaves the outcome unknown as a native protocol
+      // failure does.
+      outcomeUnknown: fallbackKind === 'protocol',
+    });
+  }
+  return error;
+}
+
+function cloneJson(value, budget, depth, kind) {
+  if (depth > MAX_JSON_DEPTH || ++budget.nodes > MAX_JSON_NODES) throw normalized({}, kind);
+  if (value === null || typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    budget.bytes += Buffer.byteLength(value, 'utf8');
+    if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, kind);
+    return value;
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+      throw normalized({}, kind);
+    }
+    return value;
+  }
+  if (value === undefined || typeof value !== 'object' || isProxy(value)) {
+    throw normalized({}, kind);
+  }
+  const array = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
+    throw normalized({}, kind);
+  }
+  if (budget.active.has(value)) throw normalized({}, kind);
+  budget.active.add(value);
+  try {
+    if (array) return value.map((member) => cloneJson(member, budget, depth + 1, kind));
+    const result = Object.create(null);
+    for (const key of Reflect.ownKeys(value)) {
+      if (typeof key !== 'string') throw normalized({}, kind);
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !Object.hasOwn(descriptor, 'value')) throw normalized({}, kind);
+      if (descriptor.enumerable) {
+        budget.bytes += Buffer.byteLength(key, 'utf8');
+        if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, kind);
+        result[key] = cloneJson(descriptor.value, budget, depth + 1, kind);
+      }
+    }
+    return result;
+  } finally {
+    budget.active.delete(value);
+  }
+}
+
+// A refusal is reported as `kind`: `configuration` for the constructor's
+// settings, `invalid-request` for a method's arguments.
+function sanitize(value, kind) {
+  return cloneJson(value, { nodes: 0, bytes: 0, active: new WeakSet() }, 0, kind);
+}
+
+const NativeSchedulingClient = native.SchedulingClient;
+
+class SchedulingClient {
+  constructor(config) {
+    try {
+      this.native = new NativeSchedulingClient(sanitize(config, 'configuration'));
+    } catch (error) {
+      throw normalized(error, 'configuration');
+    }
+  }
+}
+
+for (const [method, jsonIndexes] of [
+  ['getScheduling', []],
+  ['listServices', []],
+  ['listOfferings', []],
+  ['availability', [2]],
+  ['explain', []],
+  ['createHold', [2]],
+  ['releaseHold', []],
+  ['createAppointment', [2]],
+  ['getAppointment', []],
+  ['listAppointments', [1, 2]],
+  ['rescheduleAppointment', [3]],
+  ['cancelAppointment', [3]],
+  ['appointmentHistory', []],
+  ['listResources', []],
+  ['listLocations', []],
+]) {
+  SchedulingClient.prototype[method] = function (...args) {
+    try {
+      for (const index of jsonIndexes) {
+        if (args[index] !== undefined && args[index] !== null) args[index] = sanitize(args[index], 'invalid-request');
+      }
+      return this.native[method](...args).catch((error) => { throw normalized(error, 'protocol'); });
+    } catch (error) {
+      throw normalized(error, 'invalid-request');
+    }
+  };
+}
+
+module.exports = { SchedulingClient, SchedulingClientError };

package/scheduling/index.d.ts

@@ -0,0 +1,27 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+
+export declare class SchedulingClient {
+  constructor(config: any)
+  getScheduling(token: string): Promise<SchedulingOutcome>
+  listServices(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  listOfferings(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  availability(token: string, offering: string, query?: any | undefined | null): Promise<SchedulingOutcome>
+  explain(token: string, offering: string, start: string): Promise<SchedulingOutcome>
+  createHold(token: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  releaseHold(token: string, holdId: string): Promise<SchedulingOutcome>
+  createAppointment(token: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  getAppointment(token: string, appointmentId: string): Promise<SchedulingOutcome>
+  listAppointments(token: string, reference: any, page?: any | undefined | null): Promise<SchedulingOutcome>
+  rescheduleAppointment(token: string, appointmentId: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  cancelAppointment(token: string, appointmentId: string, idempotencyKey: string, request: any): Promise<SchedulingOutcome>
+  appointmentHistory(token: string, appointmentId: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  listResources(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+  listLocations(token: string, cursor?: string | undefined | null): Promise<SchedulingOutcome>
+}
+
+export interface SchedulingOutcome {
+  kind: string
+  value: any
+  traceId: string
+}

package/scheduling/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../native').load('scheduling');

package/relay/client.d.ts

@@ -1,460 +0,0 @@
-export type JsonScalar = string | number | boolean | null
-export type JsonValue = JsonScalar | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }
-/** An integer that satisfies `Number.isSafeInteger` and the option's documented bounds. */
-export type SafeInteger = number
-
-export interface PrivateJwk {
-  readonly kty: string
-  readonly kid: string
-  readonly alg: string
-  readonly [member: string]: JsonValue
-}
-
-export interface PrivateKeyJwtConfig {
-  tokenEndpoint: string
-  clientId: string
-  clientKey: PrivateJwk
-  /**
-   * The audience of the client assertion (who checks the client's
-   * authentication). Defaults to the token endpoint URL. This is not the
-   * `resource` of the token request.
-   */
-  audience?: string | null
-  /**
-   * The RFC 8707 resource indicator the token is requested for: the resource
-   * server's registered identifier, not a URL to fetch.
-   */
-  resource?: string | null
-  /**
-   * The scopes requested for the token, sent as one space-delimited `scope`
-   * parameter. A requested scope may narrow the client's registered
-   * permission set; it can never widen it.
-   */
-  scopes?: ReadonlyArray<string> | null
-  assertionLifetimeSeconds?: SafeInteger | null
-  refreshMarginSeconds?: SafeInteger | null
-  requestTimeoutMilliseconds?: SafeInteger | null
-  connectTimeoutMilliseconds?: SafeInteger | null
-  userAgent?: string | null
-  trustedRootCertificates?: string | null
-}
-
-/** One immutable verified person or grant context. Reconstruct after host source facts change. */
-export interface ExchangeContext {
-  issuer: string
-  subject: string
-  audience: string
-  generation: string
-  deadlineSeconds: SafeInteger
-  grantId?: string | null
-}
-
-export type ExchangePrivateKeyJwtConfig = PrivateKeyJwtConfig & {
-  resource: string
-  scopes: ReadonlyArray<string>
-}
-
-export interface FirstPartyExchangeSource {
-  key: PrivateJwk
-  attributes: Readonly<Record<string, JsonValue>>
-}
-
-export interface RemoteExchangeSource {
-  endpoint: string
-  bootstrap: ExchangePrivateKeyJwtConfig
-  bootstrapResource: string
-  bootstrapScope: string
-  requestTimeoutMilliseconds?: SafeInteger | null
-  connectTimeoutMilliseconds?: SafeInteger | null
-  userAgent?: string | null
-  trustedRootCertificates?: string | null
-}
-
-export type ExchangeAuthorizationConfig =
-  | { client: ExchangePrivateKeyJwtConfig; context: ExchangeContext; firstParty: FirstPartyExchangeSource }
-  | { client: ExchangePrivateKeyJwtConfig; context: ExchangeContext; remote: RemoteExchangeSource }
-
-export type RelayAuthorization =
-  | { static: string }
-  | { privateKeyJwt: PrivateKeyJwtConfig }
-  | { exchange: ExchangeAuthorizationConfig }
-
-export interface RelayClientConfig {
-  baseUrl: string
-  authorization?: RelayAuthorization | null
-  requestTimeoutMilliseconds?: SafeInteger | null
-  connectTimeoutMilliseconds?: SafeInteger | null
-  userAgent?: string | null
-  maxResponseBytes?: SafeInteger | null
-  trustedRootCertificates?: string | null
-}
-
-export type RecordFormat = 'json' | 'json-ld' | 'geojson' | 'json-fg'
-
-export interface ResourceListOptions {
-  pageSize?: SafeInteger | null
-}
-
-export interface ResourceContinuation {
-  cursor: string
-}
-
-export interface RecordOptions {
-  fields?: ReadonlyArray<string> | null
-  accessProfile?: string | null
-  format?: RecordFormat | null
-}
-
-export interface ListOptions extends RecordOptions {
-  pageSize?: SafeInteger | null
-  filters?: Readonly<Record<string, string>> | null
-}
-
-export interface SearchOptions extends RecordOptions {
-  pageSize?: SafeInteger | null
-  /** `[west, south, east, north]` in WGS84 longitude/latitude degrees. */
-  bbox: readonly [number, number, number, number]
-}
-
-export type LookupSelector = string | SafeInteger | boolean
-export type LookupSelectors = Readonly<Record<string, LookupSelector>>
-
-export interface RecordsRoute {
-  kind: 'records'
-  resource: string
-}
-
-export interface SearchRoute {
-  kind: 'search'
-  resource: string
-  search: string
-}
-
-export interface CollectionContinuation<Route extends RecordsRoute | SearchRoute = RecordsRoute | SearchRoute> {
-  route: Route
-  cursor: string
-  format: 'json' | 'json-ld' | 'geojson-rfc7946' | 'json-fg'
-  accessProfile?: string
-}
-
-export interface SdmxDataRequest {
-  agency: string
-  resource: string
-  /** A three-part `x.y.z` SDMX version. */
-  version: string
-  key?: string | null
-  constraints?: Readonly<Record<string, string>> | null
-  offset?: SafeInteger | null
-  limit?: SafeInteger | null
-  dimensionAtObservation?: string | null
-  format?: 'json' | 'csv' | null
-}
-
-export interface SdmxStructureRequest {
-  kind: 'dataflow' | 'datastructure'
-  agency: string
-  resource: string
-  /** A three-part `x.y.z` SDMX version. */
-  version: string
-}
-
-export interface ProbeStatus {
-  status: string
-}
-
-export interface Institution {
-  identifier: string
-  name: string
-}
-
-export interface Product {
-  name: string
-  version: string
-}
-
-export interface ApiBinding {
-  name: string
-  version: string
-}
-
-export interface AlignmentTarget {
-  name: string
-  version: string
-  status: string
-  cfrTarget?: string
-}
-
-export interface FormatProfileCapability {
-  id: string
-  uri: string
-  crs: string
-  conformsTo: ReadonlyArray<string>
-}
-
-export interface WireFormatCapability {
-  id: string
-  mediaType: string
-  formatProfiles: ReadonlyArray<FormatProfileCapability>
-}
-
-export interface BboxCapability {
-  crs: string
-  predicate: string
-  maximumLongitudeSpanDegrees: number
-  maximumLatitudeSpanDegrees: number
-}
-
-export interface SpatialQueryCapability {
-  bbox: BboxCapability
-}
-
-export interface ConsultationCapability {
-  family: 'consultation'
-  pattern: string
-  resourceIdentifier: string
-  operationIdentifier: string
-  accessProfileIdentifier: string
-  isDefault: boolean
-  disclosureProfile: string
-  schemaReference: string
-  semanticModelReference: string
-  contextReference: string
-  href: string
-  wireFormats: ReadonlyArray<WireFormatCapability>
-  spatialQuery?: SpatialQueryCapability
-  classificationReference?: string
-  processingReference?: string
-}
-
-export interface SdmxProfile {
-  sdmxRestVersion: string
-  sdmxDataJsonVersion: string
-  sdmxDataCsvVersion: string
-  sdmxStructureJsonVersion: string
-}
-
-export interface SdmxWireFormat {
-  id: string
-  mediaType: string
-}
-
-export interface SdmxStructureLinks {
-  dataflow: string
-  datastructure: string
-}
-
-export interface AggregateDataCapability {
-  family: 'aggregate-data'
-  pattern: string
-  statisticalDatasetIdentifier: string
-  operationIdentifier: string
-  profile: SdmxProfile
-  wireFormats: ReadonlyArray<SdmxWireFormat>
-  href: string
-  structureLinks: SdmxStructureLinks
-}
-
-export type Capability = ConsultationCapability | AggregateDataCapability
-
-export interface ServiceMetadata {
-  registryIdentifier: string
-  name: string
-  authority: Institution
-  operator: Institution | null
-  authoritativeScope: string
-  product: Product
-  apiBinding: ApiBinding
-  alignmentTargets: ReadonlyArray<AlignmentTarget>
-  capabilities: ReadonlyArray<Capability>
-  links: { self: string; resources: string; openapi: string }
-}
-
-export interface ResourceDocument {
-  resourceIdentifier: string
-  title: string
-  description: string
-  semanticClass: string
-  enumerationPosture: string
-  capabilities: ReadonlyArray<Capability>
-  links: { self: string }
-}
-
-export interface CursorPageInfo {
-  nextCursor: string | null
-}
-
-export interface RegistryMetadata {
-  registryIdentifier: string
-}
-
-export interface ResourceCollection {
-  items: ReadonlyArray<ResourceDocument>
-  pageInfo: CursorPageInfo
-  meta: RegistryMetadata
-}
-
-export interface ResourceEnvelope {
-  data: ResourceDocument
-  meta: RegistryMetadata
-}
-
-export interface RegistryRecord {
-  registryIdentifier: string
-  recordIdentifier: string
-  revisionIdentifier: string
-  lifecycleState: string
-  schemaReference: string
-  semanticModelReference: string
-  authorityIdentifier: string
-  recordedAt: string
-  domainData: Readonly<Record<string, JsonValue>>
-  '@id'?: string
-  '@type'?: string
-}
-
-export interface SourceRevision {
-  profile: string
-  status: string
-  value: string | null
-}
-
-export interface RecordLinks {
-  self: string
-  context: string
-  schema: string
-  semanticModel: string
-}
-
-export interface RecordMetadata {
-  operationIdentifier: string
-  accessProfile: string
-  family: string
-  pattern: string
-  disclosureProfile: string
-  contractRevision: string
-  sourceRevision: SourceRevision
-  selectedFields: ReadonlyArray<string>
-  links: RecordLinks
-}
-
-export interface RecordEnvelope {
-  data: RegistryRecord
-  meta: RecordMetadata
-  '@context'?: string
-}
-
-export interface RecordCollection {
-  items: ReadonlyArray<RegistryRecord>
-  pageInfo: CursorPageInfo
-  meta: RecordMetadata
-  '@context'?: string
-}
-
-export interface GeoJsonFeature {
-  type: string
-  id: string
-  geometry: JsonValue
-  properties: RegistryRecord
-  meta?: RecordMetadata
-  conformsTo?: ReadonlyArray<string>
-  featureType?: string
-  coordRefSys?: string
-}
-
-export interface GeoJsonFeatureCollection {
-  type: string
-  features: ReadonlyArray<GeoJsonFeature>
-  pageInfo: CursorPageInfo
-  meta: RecordMetadata
-  conformsTo?: ReadonlyArray<string>
-  featureType?: string
-  coordRefSys?: string
-}
-
-export type RecordResponse = RecordEnvelope | GeoJsonFeature
-export type RecordCollectionResponse = RecordCollection | GeoJsonFeatureCollection
-
-export interface CompleteOutcome<T> {
-  kind: 'complete'
-  value: T
-  traceId: string
-  etag?: string
-}
-
-export interface NotModifiedOutcome {
-  kind: 'notModified'
-  etag: string
-  traceId: string
-}
-
-export type Outcome<T> = CompleteOutcome<T> | NotModifiedOutcome
-
-export interface ResourcePageCompleteOutcome {
-  kind: 'complete'
-  value: ResourceCollection
-  continuation?: ResourceContinuation
-  traceId: string
-  etag?: string
-}
-
-export type ResourcePageOutcome = ResourcePageCompleteOutcome | NotModifiedOutcome
-
-export interface CollectionPageCompleteOutcome {
-  kind: 'complete'
-  value: RecordCollectionResponse
-  continuation?: CollectionContinuation
-  traceId: string
-  etag?: string
-}
-
-export type CollectionPageOutcome = CollectionPageCompleteOutcome | NotModifiedOutcome
-
-export interface RawCompleteOutcome {
-  kind: 'complete'
-  body: Buffer
-  mediaType: string
-  traceId: string
-  etag?: string
-}
-
-export type RawOutcome = RawCompleteOutcome | NotModifiedOutcome
-
-export interface RelayClientFailure extends Error {
-  readonly kind: string
-  readonly code?: string
-  readonly status?: number
-  readonly traceId?: string
-  readonly retryAfterSeconds?: number
-  readonly transportKind?: string
-  readonly tokenKind?: string
-}
-
-export declare class RelayClientError extends Error implements RelayClientFailure {
-  readonly kind: string
-  readonly code?: string
-  readonly status?: number
-  readonly traceId?: string
-  readonly retryAfterSeconds?: number
-  readonly transportKind?: string
-  readonly tokenKind?: string
-}
-
-export declare class RelayClient {
-  constructor(config: RelayClientConfig)
-  health(): Promise<CompleteOutcome<ProbeStatus>>
-  ready(): Promise<CompleteOutcome<ProbeStatus>>
-  openapi(etag?: string | null): Promise<RawOutcome>
-  serviceMetadata(etag?: string | null): Promise<Outcome<ServiceMetadata>>
-  resources(options?: ResourceListOptions | null, etag?: string | null): Promise<ResourcePageOutcome>
-  continueResources(continuation: ResourceContinuation, etag?: string | null): Promise<ResourcePageOutcome>
-  resource(resource: string, etag?: string | null): Promise<Outcome<ResourceEnvelope>>
-  listRecords(resource: string, options?: ListOptions | null, etag?: string | null): Promise<CollectionPageOutcome>
-  continueListRecords(continuation: CollectionContinuation<RecordsRoute>, etag?: string | null): Promise<CollectionPageOutcome>
-  readRecord(resource: string, recordIdentifier: string, options?: RecordOptions | null, etag?: string | null): Promise<Outcome<RecordResponse>>
-  lookup(resource: string, lookup: string, selectors: LookupSelectors, options?: RecordOptions | null, etag?: string | null): Promise<Outcome<RecordResponse>>
-  search(resource: string, search: string, options: SearchOptions, etag?: string | null): Promise<CollectionPageOutcome>
-  continueSearch(continuation: CollectionContinuation<SearchRoute>, etag?: string | null): Promise<CollectionPageOutcome>
-  artifact(artifactIdentifier: string, etag?: string | null): Promise<RawOutcome>
-  sdmxData(request: SdmxDataRequest, etag?: string | null): Promise<RawOutcome>
-  sdmxStructure(request: SdmxStructureRequest, etag?: string | null): Promise<RawOutcome>
-}