gingersnap 0.22.0

package/networking/decorators/options.mjs

@@ -0,0 +1,242 @@
+import { ResponseType, BodyType } from '../types.mjs';
+import * as R from 'ramda';
+import 'reflect-metadata';
+
+/// //// Constants ///////
+const THROTTLE_DEFAULT_MS = 3000;
+const SUPPORTED_HEADER_VALUES = ["String", "Number", "Boolean"];
+/// // // Helpers ///////
+const createProps = (constructor) => {
+    const proto = constructor.prototype;
+    if (proto.__internal__ === undefined) {
+        proto.__internal__ = { classConfig: {}, methodConfig: {} };
+    }
+    return proto;
+};
+const createResponseDecorator = (type) => ({ modelType, format, isArray, modelTypeMapping, modelTypeKeyPath } = {
+    modelType: String,
+    isArray: false,
+}) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "responseType"]);
+    const formatLens = R.lensPath(["methodConfig", propertyKey, "dataFormat"]);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "responseClass"]);
+    const isArrayLens = R.lensPath(["methodConfig", propertyKey, "responseArray"]);
+    proto.__internal__ = R.set(lens, type, proto.__internal__);
+    proto.__internal__ = R.set(typeLens, modelType, proto.__internal__);
+    proto.__internal__ = R.set(isArrayLens, isArray, proto.__internal__);
+    proto.__internal__ = R.set(formatLens, format, proto.__internal__);
+};
+const createRequestBodyDecorator = (type) => (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "body"]);
+    proto.__internal__ = R.set(lens, { type, parameterIndex }, proto.__internal__);
+};
+const createRequestMultiBodyDecorator = (type) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "body"]);
+    const changer = R.compose(R.mergeDeepLeft({ type }), R.or(R.__, {}));
+    proto.__internal__ = R.over(lens, changer, proto.__internal__);
+};
+const createRequestMultiBodyParameterDecorator = (key) => (value) => (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "body", key]);
+    const changer = R.compose(R.mergeDeepLeft({ [value]: parameterIndex }), R.or(R.__, {}));
+    proto.__internal__ = R.over(lens, changer, proto.__internal__);
+};
+/**
+ * Sets the host for the Snap Service
+ * @param value host
+ * @constructor
+ */
+const BaseUrl = (value) => (constructor) => {
+    const proto = createProps(constructor);
+    proto.__internal__.classConfig.baseUrl = value;
+};
+/**
+ * Marks the SnapService method as on that returns a JSON Response of a specific Model type
+ */
+const JSONResponse = createResponseDecorator(ResponseType.JSON);
+/**
+ * Marks the SnapService method as on that returns a XML Response of a specific Model type
+ */
+const XMLResponse = createResponseDecorator(ResponseType.XML);
+/**
+ * Marks the SnapService method as on that returns a String Response
+ */
+const StringResponse = createResponseDecorator(ResponseType.STRING)({ modelType: String });
+/**
+ * Marks the SnapService method as on that returns a Blob
+ */
+const BinaryResponse = createResponseDecorator(ResponseType.BINARY)({ modelType: Blob });
+/**
+ * Marks the SnapService method as on that has no return value
+ */
+const NoResponse = createResponseDecorator(ResponseType.NONE)();
+/**
+ * Marks the SnapService method that it should use multipart/form-data when submitting the request
+ */
+const Multipart = createRequestMultiBodyDecorator(BodyType.MULTIPART);
+/**
+ * Marks the SnapService method that it should use application/x-www-form-urlencoded when submitting the request
+ */
+const FormUrlEncoded = createRequestMultiBodyDecorator(BodyType.FORMURLENCODED);
+/**
+ * Sets the headers for the request
+ * @param value MapOfHeaders
+ * @constructor
+ */
+const Headers = (value) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "headers"]);
+    const changer = R.compose(R.mergeDeepLeft(value), R.or(R.__, {}));
+    proto.__internal__ = R.over(lens, changer, proto.__internal__);
+};
+/**
+ * Throttles the request by 3 seconds
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+const Throttle = (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "throttle"]);
+    proto.__internal__ = R.set(lens, { waitPeriodInMs: THROTTLE_DEFAULT_MS }, proto.__internal__);
+};
+/**
+ * Throttles the request by the value provided
+ * @param value ThrottleByProps - An object that contains the waitPeriodInMs
+ * @constructor
+ */
+const ThrottleBy = (value) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "throttle"]);
+    proto.__internal__ = R.set(lens, value, proto.__internal__);
+};
+/**
+ * Marks this method as an authenticator. When requests receive 401 status code, this method will be called to retrieve
+ * the credentials
+ * @param type Credentials - Type of credentials that this authenticator should return
+ * (BasicCredentials | BearerCredentials | APIKeyCredentials | define one of your own by subclassing Credentials)
+ * @param global Whether this authenticator should be used across all services
+ * @param socketField
+ * @constructor
+ */
+const Authenticator = (type, global = false, socketField = "accessToken") => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "authenticator"]);
+    proto.__internal__ = R.over(lens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { type, global })), proto.__internal__);
+};
+/**
+ * Marks this method as an auth refresher. Whenever a request receives a 401 status code for invalid credentials, this
+ * method will be called with the old Credentials, and should produce new credentials
+ * @param type Credentials - Type of credentials that this authenticator should return
+ * (BasicCredentials | BearerCredentials | APIKeyCredentials | define one of your own by subclassing Credentials)
+ * @param global Whether this auth refresher should be used across all services
+ * @constructor
+ */
+const AuthRefresher = (type, global = false) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "authRefresher"]);
+    proto.__internal__ = R.over(lens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { type, global })), proto.__internal__);
+};
+/**
+ * Marks argument as a property in the MultiPart form
+ */
+const Part = createRequestMultiBodyParameterDecorator("parts");
+/**
+ * Marks argument as a property in the FormUrlEncoded  form or a JSON payload
+ */
+const Field = createRequestMultiBodyParameterDecorator("fields");
+/**
+ * Marks argument as a property in the FormUrlEncoded  form or JSON payload, but it can be missing
+ */
+const OptionalField = createRequestMultiBodyParameterDecorator("OptionalFields");
+/**
+ * Marks argument that should be deserialized to a JSON string and attached as the body of the request
+ */
+const JSONBody = createRequestBodyDecorator(BodyType.JSON);
+/**
+ * Marks argument that should be deserialized to XML string and attached as the body of the request
+ */
+const XMLBody = createRequestBodyDecorator(BodyType.XML);
+/**
+ * Marks argument that should be the body of the request, and is a string
+ */
+const StringBody = createRequestBodyDecorator(BodyType.STRING);
+/**
+ * Marks argument that should contain a Map of the queries used in the request. Argument should be an object with each
+ * key value pair being the query name and value
+ * @constructor
+ */
+const QueryMap = (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "queries"]);
+    proto.__internal__ = R.over(lens, R.compose(R.mergeLeft({ [Symbol(propertyKey)]: parameterIndex }, R.__), R.or(R.__, {})), proto.__internal__);
+};
+/**
+ * Marks argument as a path variable in the request url
+ * @param value Name of the path variable
+ * @constructor
+ */
+const Path = (value) => {
+    return (target, propertyKey, parameterIndex) => {
+        const type = R.path([parameterIndex, "name"], Reflect.getMetadata("design:paramtypes", target, propertyKey));
+        if (!["String", "Number"].includes(type)) {
+            throw Error("Invalid type given for @Query. Should be of type string or number");
+        }
+        const proto = createProps(target.constructor);
+        const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "pathVariables"]);
+        proto.__internal__ = R.over(lens, R.compose(R.mergeDeepWith(R.concat, { [value]: parameterIndex }), R.or(R.__, {})), proto.__internal__);
+    };
+};
+/**
+ * Marks argument as a query to be attached to the request url
+ * @param value Name of the query
+ * @constructor
+ */
+const Query = (value) => {
+    return (target, propertyKey, parameterIndex) => {
+        const proto = createProps(target.constructor);
+        const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "queries"]);
+        proto.__internal__ = R.over(lens, R.compose(R.mergeDeepWith(R.concat, { [value]: parameterIndex }), R.or(R.__, {})), proto.__internal__);
+    };
+};
+/**
+ * Marks argument as a header to be attached to the request
+ * @param value Name of the header
+ * @constructor
+ */
+const Header = (value) => {
+    return (target, propertyKey, parameterIndex) => {
+        const type = R.path([parameterIndex, "name"], Reflect.getMetadata("design:paramtypes", target, propertyKey));
+        if (!SUPPORTED_HEADER_VALUES.includes(type)) {
+            throw Error("Invalid type given for @HeaderMap. Should be of type string, number or boolean");
+        }
+        const proto = createProps(target.constructor);
+        const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "headers"]);
+        proto.__internal__ = R.over(lens, R.compose(R.mergeDeepWith(R.concat, { [value]: parameterIndex }), R.or(R.__, {})), proto.__internal__);
+    };
+};
+/**
+ * Marks argument that should contain a Map of the headers used in the request. Argument should be an object with each
+ * key value pair being the header name and value
+ * @constructor
+ */
+const HeaderMap = (target, propertyKey, parameterIndex) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey, "parameters", "headers"]);
+    const key = Symbol(propertyKey);
+    proto.__internal__ = R.over(lens, R.compose(R.mergeLeft({ [key]: parameterIndex }, R.__), R.or(R.__, {})), proto.__internal__);
+};
+/**
+ * Disables any authenticator that should be applied to this method
+ * @constructor
+ */
+const NoAuth = (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const lens = R.lensPath(["methodConfig", propertyKey]);
+    proto.__internal__ = R.set(lens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { noAuth: true })), proto.__internal__);
+};
+
+export { AuthRefresher, Authenticator, BaseUrl, BinaryResponse, Field, FormUrlEncoded, Header, HeaderMap, Headers, JSONBody, JSONResponse, Multipart, NoAuth, NoResponse, OptionalField, Part, Path, Query, QueryMap, StringBody, StringResponse, THROTTLE_DEFAULT_MS, Throttle, ThrottleBy, XMLBody, XMLResponse, createProps };

package/networking/decorators/requests.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+var R = require('ramda');
+var options = require('./options.cjs');
+var types = require('../types.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+/// //// Helpers ///////
+const createRequestDecorator = (type) => (path) => (target, propertyKey) => {
+    const proto = options.createProps(target.constructor);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "requestType"]);
+    const pathLens = R__namespace.lensPath(["methodConfig", propertyKey, "apiPath"]);
+    proto.__internal__ = R__namespace.set(typeLens, type, proto.__internal__);
+    proto.__internal__ = R__namespace.set(pathLens, path, proto.__internal__);
+};
+exports.CachingMethod = void 0;
+(function (CachingMethod) {
+    CachingMethod["FALLBACK_ON_MISSING"] = "FALLBACK_ON_MISSING";
+    CachingMethod["HIT_FIRST"] = "HIT_FIRST";
+})(exports.CachingMethod || (exports.CachingMethod = {}));
+/**
+ * Marks method as a GET request
+ */
+const GET = createRequestDecorator(types.RequestType.GET);
+/**
+ * Marks method as a PUT request
+ */
+const PUT = createRequestDecorator(types.RequestType.PUT);
+/**
+ * Marks method as a POST request
+ */
+const POST = createRequestDecorator(types.RequestType.POST);
+/**
+ * Marks method as a DELETE request
+ */
+const DELETE = createRequestDecorator(types.RequestType.DELETE);
+/**
+ * Marks method as a PATCH request
+ */
+const PATCH = createRequestDecorator(types.RequestType.PATCH);
+/**
+ * Marks method as a OPTIONS request
+ */
+const OPTIONS = createRequestDecorator(types.RequestType.OPTIONS);
+/**
+ * Marks method as a HEAD request
+ */
+const HEAD = createRequestDecorator(types.RequestType.HEAD);
+const Cached = (duration, persist = false, method = exports.CachingMethod.HIT_FIRST) => (target, propertyKey) => {
+    const proto = options.createProps(target.constructor);
+    const cacheLens = R__namespace.lensPath(["methodConfig", propertyKey, "cache"]);
+    proto.__internal__ = R__namespace.set(cacheLens, { duration, persist, method }, proto.__internal__);
+};
+
+exports.Cached = Cached;
+exports.DELETE = DELETE;
+exports.GET = GET;
+exports.HEAD = HEAD;
+exports.OPTIONS = OPTIONS;
+exports.PATCH = PATCH;
+exports.POST = POST;
+exports.PUT = PUT;

package/networking/decorators/requests.d.ts

@@ -0,0 +1,34 @@
+import { WaitPeriod } from "../../future";
+export declare enum CachingMethod {
+    FALLBACK_ON_MISSING = "FALLBACK_ON_MISSING",
+    HIT_FIRST = "HIT_FIRST"
+}
+/**
+ * Marks method as a GET request
+ */
+export declare const GET: (path: string) => (target: any, propertyKey: string) => void;
+/**
+ * Marks method as a PUT request
+ */
+export declare const PUT: (path: string) => (target: any, propertyKey: string) => void;
+/**
+ * Marks method as a POST request
+ */
+export declare const POST: (path: string) => (target: any, propertyKey: string) => void;
+/**
+ * Marks method as a DELETE request
+ */
+export declare const DELETE: (path: string) => (target: any, propertyKey: string) => void;
+/**
+ * Marks method as a PATCH request
+ */
+export declare const PATCH: (path: string) => (target: any, propertyKey: string) => void;
+/**
+ * Marks method as a OPTIONS request
+ */
+export declare const OPTIONS: (path: string) => (target: any, propertyKey: string) => void;
+/**
+ * Marks method as a HEAD request
+ */
+export declare const HEAD: (path: string) => (target: any, propertyKey: string) => void;
+export declare const Cached: (duration: WaitPeriod, persist?: boolean, method?: CachingMethod) => (target: any, propertyKey: string) => void;

package/networking/decorators/requests.mjs

@@ -0,0 +1,52 @@
+import * as R from 'ramda';
+import { createProps } from './options.mjs';
+import { RequestType } from '../types.mjs';
+
+/// //// Helpers ///////
+const createRequestDecorator = (type) => (path) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "requestType"]);
+    const pathLens = R.lensPath(["methodConfig", propertyKey, "apiPath"]);
+    proto.__internal__ = R.set(typeLens, type, proto.__internal__);
+    proto.__internal__ = R.set(pathLens, path, proto.__internal__);
+};
+var CachingMethod;
+(function (CachingMethod) {
+    CachingMethod["FALLBACK_ON_MISSING"] = "FALLBACK_ON_MISSING";
+    CachingMethod["HIT_FIRST"] = "HIT_FIRST";
+})(CachingMethod || (CachingMethod = {}));
+/**
+ * Marks method as a GET request
+ */
+const GET = createRequestDecorator(RequestType.GET);
+/**
+ * Marks method as a PUT request
+ */
+const PUT = createRequestDecorator(RequestType.PUT);
+/**
+ * Marks method as a POST request
+ */
+const POST = createRequestDecorator(RequestType.POST);
+/**
+ * Marks method as a DELETE request
+ */
+const DELETE = createRequestDecorator(RequestType.DELETE);
+/**
+ * Marks method as a PATCH request
+ */
+const PATCH = createRequestDecorator(RequestType.PATCH);
+/**
+ * Marks method as a OPTIONS request
+ */
+const OPTIONS = createRequestDecorator(RequestType.OPTIONS);
+/**
+ * Marks method as a HEAD request
+ */
+const HEAD = createRequestDecorator(RequestType.HEAD);
+const Cached = (duration, persist = false, method = CachingMethod.HIT_FIRST) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const cacheLens = R.lensPath(["methodConfig", propertyKey, "cache"]);
+    proto.__internal__ = R.set(cacheLens, { duration, persist, method }, proto.__internal__);
+};
+
+export { Cached, CachingMethod, DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT };

package/networking/decorators/socket.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+var options = require('./options.cjs');
+var R = require('ramda');
+var uuid = require('uuid');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+const ReadStream = (keyPath, value) => (target, propertyKey) => {
+    if (keyPath !== "*" && (value === undefined || value === null))
+        throw new Error("KeyPath requires a value, unless keyPath is *");
+    const proto = options.createProps(target.constructor);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R__namespace.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { keyPath,
+        value, array: false })), proto.__internal__);
+};
+const MatcherKey = (name) => (target, propertyKey, parameterIndex) => { };
+const MatcherValue = (name) => (target, propertyKey, parameterIndex) => { };
+const WriteStream = (target, propertyKey) => {
+    const proto = options.createProps(target.constructor);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "socketWriteStream"]);
+    proto.__internal__ = R__namespace.set(typeLens, true, proto.__internal__);
+};
+const RequestReply = (guidPath, guidGen = () => uuid.v4(), objectMaxSize, expiryPeriod) => (target, propertyKey) => {
+    const proto = options.createProps(target.constructor);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "socketRequestReply"]);
+    proto.__internal__ = R__namespace.set(typeLens, { guidPath, guidGen, objectMaxSize, expiryPeriod }, proto.__internal__);
+};
+const ReplyableStream = (keyPath, responseKeyPath) => (target, propertyKey) => {
+    options.createProps(target.constructor);
+    R__namespace.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+};
+const IgnoreCache = (target, propertyKey) => {
+    const proto = options.createProps(target.constructor);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R__namespace.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { ignoreCache: true })), proto.__internal__);
+};
+const Skip = (amount) => (target, propertyKey) => {
+    const proto = options.createProps(target.constructor);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R__namespace.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { skip: amount })), proto.__internal__);
+};
+const Take = (amount) => (target, propertyKey) => {
+    const proto = options.createProps(target.constructor);
+    const typeLens = R__namespace.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R__namespace.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { take: amount })), proto.__internal__);
+};
+// Decoder must return an object
+const DataDecoder = (Decoder) => (constructor) => {
+    const proto = options.createProps(constructor);
+    const typeLens = R__namespace.lensPath(["classConfig", "Decoder"]);
+    proto.__internal__ = R__namespace.set(typeLens, Decoder, proto.__internal__);
+};
+
+exports.DataDecoder = DataDecoder;
+exports.IgnoreCache = IgnoreCache;
+exports.MatcherKey = MatcherKey;
+exports.MatcherValue = MatcherValue;
+exports.ReadStream = ReadStream;
+exports.ReplyableStream = ReplyableStream;
+exports.RequestReply = RequestReply;
+exports.Skip = Skip;
+exports.Take = Take;
+exports.WriteStream = WriteStream;

package/networking/decorators/socket.d.ts

@@ -0,0 +1,13 @@
+import { WaitPeriod } from "../../future";
+export declare const ReadStream: (keyPath: string | (string | number)[] | {
+    [string: string]: string;
+}, value?: string | number | boolean | RegExp) => (target: any, propertyKey: string) => void;
+export declare const MatcherKey: (name: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+export declare const MatcherValue: (name: string) => (target: any, propertyKey: string, parameterIndex: number) => void;
+export declare const WriteStream: (target: any, propertyKey: string) => void;
+export declare const RequestReply: (guidPath: Array<string | number>, guidGen?: () => any, objectMaxSize?: number, expiryPeriod?: WaitPeriod) => (target: any, propertyKey: string) => void;
+export declare const ReplyableStream: (keyPath: string | Array<string | number>, responseKeyPath?: string | Array<string | number>) => (target: any, propertyKey: string) => void;
+export declare const IgnoreCache: (target: any, propertyKey: string) => void;
+export declare const Skip: (amount: number) => (target: any, propertyKey: string) => void;
+export declare const Take: (amount: number) => (target: any, propertyKey: string) => void;
+export declare const DataDecoder: (Decoder: any) => (constructor: any) => void;

package/networking/decorators/socket.mjs

@@ -0,0 +1,51 @@
+import { createProps } from './options.mjs';
+import * as R from 'ramda';
+import { v4 } from 'uuid';
+
+const ReadStream = (keyPath, value) => (target, propertyKey) => {
+    if (keyPath !== "*" && (value === undefined || value === null))
+        throw new Error("KeyPath requires a value, unless keyPath is *");
+    const proto = createProps(target.constructor);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { keyPath,
+        value, array: false })), proto.__internal__);
+};
+const MatcherKey = (name) => (target, propertyKey, parameterIndex) => { };
+const MatcherValue = (name) => (target, propertyKey, parameterIndex) => { };
+const WriteStream = (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "socketWriteStream"]);
+    proto.__internal__ = R.set(typeLens, true, proto.__internal__);
+};
+const RequestReply = (guidPath, guidGen = () => v4(), objectMaxSize, expiryPeriod) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "socketRequestReply"]);
+    proto.__internal__ = R.set(typeLens, { guidPath, guidGen, objectMaxSize, expiryPeriod }, proto.__internal__);
+};
+const ReplyableStream = (keyPath, responseKeyPath) => (target, propertyKey) => {
+    createProps(target.constructor);
+    R.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+};
+const IgnoreCache = (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { ignoreCache: true })), proto.__internal__);
+};
+const Skip = (amount) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { skip: amount })), proto.__internal__);
+};
+const Take = (amount) => (target, propertyKey) => {
+    const proto = createProps(target.constructor);
+    const typeLens = R.lensPath(["methodConfig", propertyKey, "socketReadStream"]);
+    proto.__internal__ = R.over(typeLens, (v) => (Object.assign(Object.assign({}, (v !== null && v !== void 0 ? v : {})), { take: amount })), proto.__internal__);
+};
+// Decoder must return an object
+const DataDecoder = (Decoder) => (constructor) => {
+    const proto = createProps(constructor);
+    const typeLens = R.lensPath(["classConfig", "Decoder"]);
+    proto.__internal__ = R.set(typeLens, Decoder, proto.__internal__);
+};
+
+export { DataDecoder, IgnoreCache, MatcherKey, MatcherValue, ReadStream, ReplyableStream, RequestReply, Skip, Take, WriteStream };

package/networking/http.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * HTTP Status codes as ENUM values
+ */
+exports.HTTPStatus = void 0;
+(function (HTTPStatus) {
+    HTTPStatus[HTTPStatus["OFFLINE"] = 0] = "OFFLINE";
+    HTTPStatus[HTTPStatus["CONTINUE"] = 100] = "CONTINUE";
+    HTTPStatus[HTTPStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    HTTPStatus[HTTPStatus["PROCESSING"] = 102] = "PROCESSING";
+    HTTPStatus[HTTPStatus["EARLY_HINTS"] = 103] = "EARLY_HINTS";
+    HTTPStatus[HTTPStatus["OK"] = 200] = "OK";
+    HTTPStatus[HTTPStatus["CREATED"] = 201] = "CREATED";
+    HTTPStatus[HTTPStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    HTTPStatus[HTTPStatus["NON_AUTHORITATIVE_INFO"] = 203] = "NON_AUTHORITATIVE_INFO";
+    HTTPStatus[HTTPStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    HTTPStatus[HTTPStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    HTTPStatus[HTTPStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    HTTPStatus[HTTPStatus["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+    HTTPStatus[HTTPStatus["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+    HTTPStatus[HTTPStatus["IM_USED"] = 209] = "IM_USED";
+    HTTPStatus[HTTPStatus["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+    HTTPStatus[HTTPStatus["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+    HTTPStatus[HTTPStatus["FOUND"] = 302] = "FOUND";
+    HTTPStatus[HTTPStatus["SEE_OTHER"] = 303] = "SEE_OTHER";
+    HTTPStatus[HTTPStatus["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+    HTTPStatus[HTTPStatus["USE_PROXY"] = 305] = "USE_PROXY";
+    HTTPStatus[HTTPStatus["SWITCH_PROXY"] = 306] = "SWITCH_PROXY";
+    HTTPStatus[HTTPStatus["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+    HTTPStatus[HTTPStatus["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+    HTTPStatus[HTTPStatus["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    HTTPStatus[HTTPStatus["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    HTTPStatus[HTTPStatus["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+    HTTPStatus[HTTPStatus["FORBIDDEN"] = 403] = "FORBIDDEN";
+    HTTPStatus[HTTPStatus["NOT_FOUND"] = 404] = "NOT_FOUND";
+    HTTPStatus[HTTPStatus["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+    HTTPStatus[HTTPStatus["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+    HTTPStatus[HTTPStatus["PROXY_AUTH_REQUIRED"] = 407] = "PROXY_AUTH_REQUIRED";
+    HTTPStatus[HTTPStatus["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+    HTTPStatus[HTTPStatus["CONFLICT"] = 409] = "CONFLICT";
+    HTTPStatus[HTTPStatus["GONE"] = 410] = "GONE";
+    HTTPStatus[HTTPStatus["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+    HTTPStatus[HTTPStatus["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+    HTTPStatus[HTTPStatus["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+    HTTPStatus[HTTPStatus["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+    HTTPStatus[HTTPStatus["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+    HTTPStatus[HTTPStatus["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+    HTTPStatus[HTTPStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    HTTPStatus[HTTPStatus["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+    HTTPStatus[HTTPStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    HTTPStatus[HTTPStatus["LOCKED"] = 423] = "LOCKED";
+    HTTPStatus[HTTPStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    HTTPStatus[HTTPStatus["TOO_EARLY"] = 425] = "TOO_EARLY";
+    HTTPStatus[HTTPStatus["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+    HTTPStatus[HTTPStatus["PRECONDITION_FAILURE"] = 428] = "PRECONDITION_FAILURE";
+    HTTPStatus[HTTPStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    HTTPStatus[HTTPStatus["REQUEST_HEADER_FIELD_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELD_TOO_LARGE";
+    HTTPStatus[HTTPStatus["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+    HTTPStatus[HTTPStatus["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+    HTTPStatus[HTTPStatus["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+    HTTPStatus[HTTPStatus["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+    HTTPStatus[HTTPStatus["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+    HTTPStatus[HTTPStatus["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+    HTTPStatus[HTTPStatus["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+    HTTPStatus[HTTPStatus["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+    HTTPStatus[HTTPStatus["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+    HTTPStatus[HTTPStatus["NETWORK_AUTH_REQUIRED"] = 511] = "NETWORK_AUTH_REQUIRED";
+})(exports.HTTPStatus || (exports.HTTPStatus = {}));