@sdk-it/rpc 0.29.0

package/dist/index.js

@@ -0,0 +1,756 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/rpc/src/lib/rpc.ts
+import { z as z2 } from "zod";
+import { augmentSpec, forEachOperation, loadSpec } from "@sdk-it/spec";
+import { buildInput, inputToPath, toHttpOutput } from "@sdk-it/typescript";
+
+// packages/rpc/src/lib/http/dispatcher.ts
+import z from "zod";
+
+// packages/rpc/src/lib/http/interceptors.ts
+var createHeadersInterceptor = (defaultHeaders, requestHeaders) => {
+  return {
+    before({ init, url }) {
+      const headers = defaultHeaders();
+      for (const [key, value] of new Headers(requestHeaders)) {
+        if (value !== void 0 && !init.headers.has(key)) {
+          init.headers.set(key, value);
+        }
+      }
+      for (const [key, value] of Object.entries(headers)) {
+        if (value !== void 0 && !init.headers.has(key)) {
+          init.headers.set(key, value);
+        }
+      }
+      return { init, url };
+    }
+  };
+};
+var createBaseUrlInterceptor = (getBaseUrl) => {
+  return {
+    before({ init, url }) {
+      const baseUrl = getBaseUrl();
+      if (url.protocol === "local:") {
+        return {
+          init,
+          url: new URL(url.href.replace("local://", baseUrl))
+        };
+      }
+      return { init, url };
+    }
+  };
+};
+
+// packages/rpc/src/lib/http/request.ts
+function createUrl(path, query) {
+  const url = new URL(path, `local://`);
+  url.search = query.toString();
+  return url;
+}
+function template(templateString, templateVariables) {
+  const nargs = /{([0-9a-zA-Z_]+)}/g;
+  return templateString.replace(nargs, (match, key, index) => {
+    if (templateString[index - 1] === "{" && templateString[index + match.length] === "}") {
+      return key;
+    }
+    const result = key in templateVariables ? templateVariables[key] : null;
+    return result === null || result === void 0 ? "" : String(result);
+  });
+}
+var Serializer = class {
+  input;
+  props;
+  constructor(input, props) {
+    this.input = input;
+    this.props = props;
+  }
+  serialize() {
+    const headers = new Headers({});
+    for (const header of this.props.inputHeaders) {
+      headers.set(header, this.input[header]);
+    }
+    const query = new URLSearchParams();
+    for (const key of this.props.inputQuery) {
+      const value = this.input[key];
+      if (value !== void 0) {
+        query.set(key, String(value));
+      }
+    }
+    const params = this.props.inputParams.reduce(
+      (acc, key) => {
+        acc[key] = this.input[key];
+        return acc;
+      },
+      {}
+    );
+    return {
+      body: this.getBody(),
+      query,
+      params,
+      headers: this.getHeaders()
+    };
+  }
+};
+var JsonSerializer = class extends Serializer {
+  getBody() {
+    const body = {};
+    if (this.props.inputBody.length === 1 && this.props.inputBody[0] === "$body") {
+      return JSON.stringify(this.input.$body);
+    }
+    for (const prop of this.props.inputBody) {
+      body[prop] = this.input[prop];
+    }
+    return JSON.stringify(body);
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+  }
+};
+var UrlencodedSerializer = class extends Serializer {
+  getBody() {
+    const body = new URLSearchParams();
+    for (const prop of this.props.inputBody) {
+      body.set(prop, this.input[prop]);
+    }
+    return body;
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    };
+  }
+};
+var EmptySerializer = class extends Serializer {
+  getBody() {
+    return null;
+  }
+  getHeaders() {
+    return {};
+  }
+};
+var FormDataSerializer = class extends Serializer {
+  getBody() {
+    const body = new FormData();
+    for (const prop of this.props.inputBody) {
+      body.append(prop, this.input[prop]);
+    }
+    return body;
+  }
+  getHeaders() {
+    return {
+      Accept: "application/json"
+    };
+  }
+};
+function json(input, props) {
+  return new JsonSerializer(input, props).serialize();
+}
+function urlencoded(input, props) {
+  return new UrlencodedSerializer(input, props).serialize();
+}
+function empty(input, props) {
+  return new EmptySerializer(input, props).serialize();
+}
+function formdata(input, props) {
+  return new FormDataSerializer(input, props).serialize();
+}
+function toRequest(endpoint, input) {
+  const [method, path] = endpoint.split(" ");
+  const pathVariable = template(path, input.params);
+  return {
+    url: createUrl(pathVariable, input.query),
+    init: {
+      method,
+      headers: new Headers(input.headers),
+      body: method === "GET" ? void 0 : input.body
+    }
+  };
+}
+
+// packages/rpc/src/lib/http/parse-response.ts
+import { parse } from "fast-content-type-parse";
+async function buffered(response) {
+  const contentType = response.headers.get("Content-Type");
+  if (!contentType) {
+    throw new Error("Content-Type header is missing");
+  }
+  if (response.status === 204) {
+    return null;
+  }
+  const { type } = parse(contentType);
+  switch (type) {
+    case "application/json":
+      return response.json();
+    case "text/plain":
+      return response.text();
+    case "text/html":
+      return response.text();
+    case "text/xml":
+    case "application/xml":
+      return response.text();
+    case "application/x-www-form-urlencoded": {
+      const text = await response.text();
+      return Object.fromEntries(new URLSearchParams(text));
+    }
+    case "multipart/form-data":
+      return response.formData();
+    default:
+      throw new Error(`Unsupported content type: ${contentType}`);
+  }
+}
+
+// packages/rpc/src/lib/http/response.ts
+var response_exports = {};
+__export(response_exports, {
+  APIError: () => APIError,
+  APIResponse: () => APIResponse,
+  Accepted: () => Accepted,
+  BadGateway: () => BadGateway,
+  BadRequest: () => BadRequest,
+  Conflict: () => Conflict,
+  Created: () => Created,
+  Forbidden: () => Forbidden,
+  GatewayTimeout: () => GatewayTimeout,
+  Gone: () => Gone,
+  InternalServerError: () => InternalServerError,
+  KIND: () => KIND,
+  MethodNotAllowed: () => MethodNotAllowed,
+  NoContent: () => NoContent,
+  NotAcceptable: () => NotAcceptable,
+  NotFound: () => NotFound,
+  NotImplemented: () => NotImplemented,
+  Ok: () => Ok,
+  PayloadTooLarge: () => PayloadTooLarge,
+  PaymentRequired: () => PaymentRequired,
+  PreconditionFailed: () => PreconditionFailed,
+  ServiceUnavailable: () => ServiceUnavailable,
+  TooManyRequests: () => TooManyRequests,
+  Unauthorized: () => Unauthorized,
+  UnprocessableEntity: () => UnprocessableEntity,
+  UnsupportedMediaType: () => UnsupportedMediaType
+});
+var KIND = Symbol("APIDATA");
+var APIResponse = class {
+  static status;
+  static kind = Symbol.for("APIResponse");
+  status;
+  data;
+  constructor(status, data) {
+    this.status = status;
+    this.data = data;
+  }
+  static create(status, data) {
+    return new this(status, data);
+  }
+};
+var APIError = class extends APIResponse {
+  static create(status, data) {
+    return new this(status, data);
+  }
+};
+var Ok = class _Ok extends APIResponse {
+  static kind = Symbol.for("Ok");
+  static status = 200;
+  constructor(data) {
+    super(_Ok.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var Created = class _Created extends APIResponse {
+  static kind = Symbol.for("Created");
+  static status = 201;
+  constructor(data) {
+    super(_Created.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var Accepted = class _Accepted extends APIResponse {
+  static kind = Symbol.for("Accepted");
+  static status = 202;
+  constructor(data) {
+    super(_Accepted.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var NoContent = class _NoContent extends APIResponse {
+  static kind = Symbol.for("NoContent");
+  static status = 204;
+  constructor() {
+    super(_NoContent.status, null);
+  }
+  static create(status, data) {
+    return new this();
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var BadRequest = class _BadRequest extends APIError {
+  static kind = Symbol.for("BadRequest");
+  static status = 400;
+  constructor(data) {
+    super(_BadRequest.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var Unauthorized = class _Unauthorized extends APIError {
+  static kind = Symbol.for("Unauthorized");
+  static status = 401;
+  constructor(data) {
+    super(_Unauthorized.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var PaymentRequired = class _PaymentRequired extends APIError {
+  static kind = Symbol.for("PaymentRequired");
+  static status = 402;
+  constructor(data) {
+    super(_PaymentRequired.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var Forbidden = class _Forbidden extends APIError {
+  static kind = Symbol.for("Forbidden");
+  static status = 403;
+  constructor(data) {
+    super(_Forbidden.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var NotFound = class _NotFound extends APIError {
+  static kind = Symbol.for("NotFound");
+  static status = 404;
+  constructor(data) {
+    super(_NotFound.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var MethodNotAllowed = class _MethodNotAllowed extends APIError {
+  static kind = Symbol.for("MethodNotAllowed");
+  static status = 405;
+  constructor(data) {
+    super(_MethodNotAllowed.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var NotAcceptable = class _NotAcceptable extends APIError {
+  static kind = Symbol.for("NotAcceptable");
+  static status = 406;
+  constructor(data) {
+    super(_NotAcceptable.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var Conflict = class _Conflict extends APIError {
+  static kind = Symbol.for("Conflict");
+  static status = 409;
+  constructor(data) {
+    super(_Conflict.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var Gone = class _Gone extends APIError {
+  static kind = Symbol.for("Gone");
+  static status = 410;
+  constructor(data) {
+    super(_Gone.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var PreconditionFailed = class _PreconditionFailed extends APIError {
+  static kind = Symbol.for("PreconditionFailed");
+  static status = 412;
+  constructor(data) {
+    super(_PreconditionFailed.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var UnprocessableEntity = class _UnprocessableEntity extends APIError {
+  static kind = Symbol.for("UnprocessableEntity");
+  static status = 422;
+  constructor(data) {
+    super(_UnprocessableEntity.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var TooManyRequests = class _TooManyRequests extends APIError {
+  static kind = Symbol.for("TooManyRequests");
+  static status = 429;
+  constructor(data) {
+    super(_TooManyRequests.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var PayloadTooLarge = class _PayloadTooLarge extends APIError {
+  static kind = Symbol.for("PayloadTooLarge");
+  static status = 413;
+  constructor(data) {
+    super(_PayloadTooLarge.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var UnsupportedMediaType = class _UnsupportedMediaType extends APIError {
+  static kind = Symbol.for("UnsupportedMediaType");
+  static status = 415;
+  constructor(data) {
+    super(_UnsupportedMediaType.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var InternalServerError = class _InternalServerError extends APIError {
+  static kind = Symbol.for("InternalServerError");
+  static status = 500;
+  constructor(data) {
+    super(_InternalServerError.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var NotImplemented = class _NotImplemented extends APIError {
+  static kind = Symbol.for("NotImplemented");
+  static status = 501;
+  constructor(data) {
+    super(_NotImplemented.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var BadGateway = class _BadGateway extends APIError {
+  static kind = Symbol.for("BadGateway");
+  static status = 502;
+  constructor(data) {
+    super(_BadGateway.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var ServiceUnavailable = class _ServiceUnavailable extends APIError {
+  static kind = Symbol.for("ServiceUnavailable");
+  static status = 503;
+  constructor(data) {
+    super(_ServiceUnavailable.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+var GatewayTimeout = class _GatewayTimeout extends APIError {
+  static kind = Symbol.for("GatewayTimeout");
+  static status = 504;
+  constructor(data) {
+    super(_GatewayTimeout.status, data);
+  }
+  static create(status, data) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+  static is(value) {
+    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  }
+};
+
+// packages/rpc/src/lib/http/dispatcher.ts
+var fetchType = z.function().args(z.instanceof(Request)).returns(z.promise(z.instanceof(Response))).optional();
+async function parse2(outputs, response) {
+  let output = null;
+  let parser = buffered;
+  for (const outputType of outputs) {
+    if ("parser" in outputType) {
+      parser = outputType.parser;
+      if (isTypeOf(outputType.type, APIResponse)) {
+        if (response.status === outputType.type.status) {
+          output = outputType.type;
+          break;
+        }
+      }
+    } else if (isTypeOf(outputType, APIResponse)) {
+      if (response.status === outputType.status) {
+        output = outputType;
+        break;
+      }
+    }
+  }
+  if (response.ok) {
+    const apiresponse = (output || APIResponse).create(
+      response.status,
+      await parser(response)
+    );
+    return apiresponse;
+  }
+  throw (output || APIError).create(response.status, await parser(response));
+}
+function isTypeOf(instance, baseType) {
+  if (instance === baseType) {
+    return true;
+  }
+  const prototype = Object.getPrototypeOf(instance);
+  if (prototype === null) {
+    return false;
+  }
+  return isTypeOf(prototype, baseType);
+}
+var Dispatcher = class {
+  #interceptors = [];
+  #fetch;
+  constructor(interceptors, fetch2) {
+    this.#interceptors = interceptors;
+    this.#fetch = fetch2;
+  }
+  async send(config, outputs, signal) {
+    for (const interceptor of this.#interceptors) {
+      if (interceptor.before) {
+        config = await interceptor.before(config);
+      }
+    }
+    let response = await (this.#fetch ?? fetch)(
+      new Request(config.url, config.init),
+      {
+        ...config.init,
+        signal
+      }
+    );
+    for (let i = this.#interceptors.length - 1; i >= 0; i--) {
+      const interceptor = this.#interceptors[i];
+      if (interceptor.after) {
+        response = await interceptor.after(response.clone());
+      }
+    }
+    return await parse2(outputs, response);
+  }
+};
+
+// packages/rpc/src/lib/rpc.ts
+var optionsSchema = z2.object({
+  token: z2.string().optional().transform((val) => val ? `Bearer ${val}` : void 0),
+  fetch: fetchType,
+  baseUrl: z2.string()
+});
+var Client = class {
+  options;
+  schemas;
+  constructor(options, schemas) {
+    this.options = optionsSchema.parse(options);
+    this.schemas = schemas;
+  }
+  async request(endpoint, input, options) {
+    const route = this.schemas[endpoint];
+    console.log(route);
+    const withDefaultInputs = Object.assign({}, this.#defaultInputs, input);
+    const parsedInput = input;
+    const result = await route.dispatch(parsedInput, {
+      fetch: this.options.fetch,
+      interceptors: [
+        createHeadersInterceptor(
+          () => this.defaultHeaders,
+          options?.headers ?? {}
+        ),
+        createBaseUrlInterceptor(() => this.options.baseUrl)
+      ],
+      signal: options?.signal
+    });
+    return result;
+  }
+  get defaultHeaders() {
+    return { authorization: this.options["token"] };
+  }
+  get #defaultInputs() {
+    return {};
+  }
+  setOptions(options) {
+    const validated = optionsSchema.partial().parse(options);
+    for (const key of Object.keys(validated)) {
+      if (validated[key] !== void 0) {
+        this.options[key] = validated[key];
+      }
+    }
+  }
+};
+async function rpc(openapi, options) {
+  const spec = await loadSpec(openapi);
+  const ir = augmentSpec({ spec, responses: { flattenErrorResponses: true } });
+  const schemas = {};
+  forEachOperation(ir, (entry, operation) => {
+    const endpoint = `${entry.method.toUpperCase()} ${entry.path}`;
+    const details = buildInput(ir, operation);
+    const contentTypeMap = {
+      json,
+      urlencoded,
+      formdata,
+      empty
+    };
+    console.log(operation.responses);
+    const outputs = Object.keys(operation.responses).flatMap(
+      (status) => toHttpOutput(
+        spec,
+        operation.operationId,
+        status,
+        operation.responses[status],
+        false
+      )
+    );
+    schemas[endpoint] = {
+      output: outputs.map((it) => response_exports[it.replace("http.", "")]),
+      toRequest(input) {
+        const serializer = contentTypeMap[details.outgoingContentType] || defaultSerializer(details.outgoingContentType);
+        return toRequest(
+          endpoint,
+          serializer(input, inputToPath(operation, details.inputs))
+        );
+      },
+      async dispatch(input, options2) {
+        const dispatcher = new Dispatcher(options2.interceptors, options2.fetch);
+        const result = await dispatcher.send(
+          this.toRequest(input),
+          this.output
+        );
+        return result;
+      }
+    };
+  });
+  console.log(schemas);
+  return new Client(
+    {
+      ...options,
+      baseUrl: options?.baseUrl ?? ir.servers[0].url
+    },
+    schemas
+  );
+}
+function defaultSerializer(ct) {
+  throw new Error(`Unsupported content type: ${ct}`);
+}
+export {
+  Client,
+  rpc
+};
+//# sourceMappingURL=index.js.map