haveapi-typescript-client 0.31.0

data/template/runtime.ts.erb

@@ -0,0 +1,169 @@
+// Generated by HaveAPI. Regenerate from the recorded schema; do not edit.
+import type {RequestSpec, RequestResult} from <%= literal(@runtime_import) %>;
+
+export type JsonValue = null | boolean | number | string | JsonValue[] | {[key: string]: JsonValue};
+export type RequestExecutor = (spec: RequestSpec) => Promise<RequestResult<unknown>>;
+export interface ClientOptions {execute: RequestExecutor}
+
+interface Field {
+  wire_name: string;
+  emitted_name: string;
+  kind: string;
+  required: boolean;
+  nullable: boolean;
+}
+interface Action {
+  method: string;
+  path: string;
+  placeholders: readonly (readonly [string, string])[];
+  inputNamespace: string | null;
+  outputNamespace: string | null;
+  metaNamespace: string;
+  input: readonly Field[] | null;
+  globalInput: readonly Field[] | null;
+  objectInput: readonly Field[] | null;
+}
+interface Options {
+  path?: Record<string, string | number> | undefined;
+  params?: Record<string, unknown> | undefined;
+  meta?: Record<string, unknown> | undefined;
+  headers?: RequestSpec['headers'];
+  signal?: RequestSpec['signal'];
+  timeoutMs?: RequestSpec['timeoutMs'];
+}
+
+function own(value: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function fail(message: string): never {
+  throw new TypeError(message);
+}
+function assertJson(value: unknown, label: string, seen = new Set<object>()): void {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return;
+  if (typeof value === 'number' && Number.isFinite(value)) return;
+  if (!value || typeof value !== 'object' || seen.has(value)) fail(`Invalid JSON value at ${label}`);
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+    fail(`Invalid JSON object at ${label}`);
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) assertJson(value[index], `${label}[${index}]`, seen);
+  } else {
+    for (const key of Object.keys(value)) assertJson((value as Record<string, unknown>)[key], `${label}.${key}`, seen);
+  }
+  seen.delete(value);
+}
+function checkValue(value: unknown, field: Field, query: boolean, label: string): void {
+  if (value === null) {
+    if (!field.nullable) fail(`Null is not allowed at ${label}`);
+    return;
+  }
+  switch (field.kind) {
+    case 'Integer':
+    case 'Resource':
+      if (typeof value !== 'number' || !Number.isSafeInteger(value)) fail(`Expected a safe integer at ${label}`);
+      break;
+    case 'Float':
+      if (typeof value !== 'number' || !Number.isFinite(value)) fail(`Expected a finite number at ${label}`);
+      break;
+    case 'Boolean':
+      if (typeof value !== 'boolean') fail(`Expected a boolean at ${label}`);
+      break;
+    case 'String':
+    case 'Text':
+    case 'Datetime':
+      if (typeof value !== 'string') fail(`Expected a string at ${label}`);
+      break;
+    case 'Custom':
+      if (query && !['string', 'number', 'boolean'].includes(typeof value))
+        fail(`Structured Custom query input is unsupported at ${label}`);
+      assertJson(value, label);
+      break;
+    default:
+      fail(`Unsupported parameter kind at ${label}`);
+  }
+}
+function encodeFields(
+  value: Record<string, unknown> | undefined, fields: readonly Field[] | null,
+  query: boolean, label: string, extraKey?: string,
+): Record<string, unknown> | undefined {
+  if (value !== undefined && !isRecord(value)) fail(`Expected an object at ${label}`);
+  const source = value || {};
+  const definitions = fields || [];
+  for (const key of Object.keys(source)) {
+    if (key !== extraKey && !definitions.some(field => field.emitted_name === key)) fail(`Unknown parameter at ${label}.${key}`);
+  }
+  const encoded: Record<string, unknown> = Object.create(null);
+  for (const field of definitions) {
+    const entry = own(source, field.emitted_name) ? source[field.emitted_name] : undefined;
+    if (entry === undefined) {
+      if (field.required) fail(`Missing required parameter at ${label}.${field.emitted_name}`);
+      continue;
+    }
+    checkValue(entry, field, query, `${label}.${field.emitted_name}`);
+    encoded[field.wire_name] = entry;
+  }
+  return value === undefined && Object.keys(encoded).length === 0 ? undefined : encoded;
+}
+function actionPath(action: Action, values: Options['path']): string {
+  if (values !== undefined && !isRecord(values)) fail('Path parameters must be an object');
+  const source = values || {};
+  for (const key of Object.keys(source)) {
+    if (!action.placeholders.some(([, name]) => name === key)) fail(`Unknown path parameter ${key}`);
+  }
+  const encoded: Record<string, string> = Object.create(null);
+  for (const [wire, name] of action.placeholders) {
+    const value = own(source, name) ? source[name] : undefined;
+    if (typeof value === 'number') {
+      if (!Number.isSafeInteger(value)) fail(`Expected a safe integer path parameter ${name}`);
+    } else if (typeof value !== 'string' || value.length === 0) {
+      fail(`Missing or invalid path parameter ${name}`);
+    }
+    // URL parsers normalize dot segments even when their dots are percent encoded.
+    if (value === '.' || value === '..') fail(`Unsafe path parameter ${name}`);
+    encoded[wire] = encodeURIComponent(String(value));
+  }
+  return action.path.replace(/\{([^}]+)\}/g, (_match, name: string) => {
+    const value = encoded[name];
+    if (value === undefined) fail(`Missing path template parameter ${name}`);
+    return value;
+  });
+}
+
+/** One send; the executor owns transport, envelope validation and error semantics. */
+export async function executeAction<T>(execute: RequestExecutor, action: Action, options: Options = {}): Promise<RequestResult<T>> {
+  if (typeof options !== 'object' || options === null || Array.isArray(options)) fail('Action options must be an object');
+  const query = action.method === 'GET' || action.method === 'OPTIONS';
+  let params = encodeFields(options.params, action.input, query, 'params', action.objectInput ? action.metaNamespace : undefined);
+  if (action.objectInput) {
+    const objectMeta = options.params && own(options.params, action.metaNamespace) ? options.params[action.metaNamespace] : undefined;
+    if (objectMeta !== undefined && !isRecord(objectMeta)) fail('Object metadata must be an object');
+    const encoded = encodeFields(objectMeta, action.objectInput, query, 'params metadata');
+    if (encoded !== undefined) {
+      if (query) fail('Object metadata query input is unsupported by HaveAPI 0.30.2');
+      params = params || Object.create(null) as Record<string, unknown>;
+      params[action.metaNamespace] = encoded;
+    }
+  }
+  const meta = encodeFields(options.meta, action.globalInput, query, 'meta');
+  if (meta !== undefined && action.inputNamespace === null && params && own(params, action.metaNamespace))
+    fail('Global metadata would overwrite root input metadata');
+  const spec: RequestSpec = {
+    method: action.method,
+    path: actionPath(action, options.path),
+    inputNamespace: action.inputNamespace,
+    outputNamespace: action.outputNamespace,
+    metaNamespace: action.metaNamespace,
+    ...(params === undefined ? {} : {params}),
+    ...(meta === undefined ? {} : {meta}),
+    ...(options.headers === undefined ? {} : {headers: options.headers}),
+    ...(options.signal === undefined ? {} : {signal: options.signal}),
+    ...(options.timeoutMs === undefined ? {} : {timeoutMs: options.timeoutMs}),
+  };
+  const response = await execute(spec);
+  // The sole response-type narrowing. Application payload fields are unvalidated;
+  // preserve the executor's metadata, full envelope and HTTP status receipt.
+  return {...response, data: response.data as T};
+}

data/template/types.ts.erb

@@ -0,0 +1,4 @@
+// Generated by HaveAPI. Regenerate from the recorded schema; do not edit.
+<% public_type_exports.each do |declaration| -%>
+<%= declaration %>
+<% end -%>

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: haveapi-typescript-client
+version: !ruby/object:Gem::Version
+  version: 0.31.0
+platform: ruby
+authors:
+- Jakub Skokan
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: haveapi-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+executables:
+- haveapi-typescript-client
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/haveapi-typescript-client
+- docs/documentation.md
+- haveapi-typescript-client.gemspec
+- lib/haveapi/typescript_client.rb
+- lib/haveapi/typescript_client/cli.rb
+- lib/haveapi/typescript_client/documentation.rb
+- lib/haveapi/typescript_client/emitter.rb
+- lib/haveapi/typescript_client/generator.rb
+- lib/haveapi/typescript_client/ir.rb
+- lib/haveapi/typescript_client/naming.rb
+- lib/haveapi/typescript_client/snapshot.rb
+- lib/haveapi/typescript_client/version.rb
+- template/action.ts.erb
+- template/api.ts.erb
+- template/index.ts.erb
+- template/resource.ts.erb
+- template/runtime.ts.erb
+- template/types.ts.erb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Generate typed TypeScript operations from saved HaveAPI schemas
+test_files: []