@map-colonies/config 1.0.0

package/dist/errors.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigError = exports.createConfigError = exports.ConfigError = void 0;
+const configErrors = {
+    optionValidationError: { code: 1, payload: [] },
+    configValidationError: { code: 2, payload: [] },
+    httpResponseError: { code: 3, payload: {} },
+    httpGeneralError: { code: 4, payload: {} },
+    schemaNotFoundError: { code: 5, payload: {} },
+    schemasPackageVersionMismatchError: { code: 6, payload: {} },
+    schemaVersionMismatchError: { code: 7, payload: {} },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+};
+/**
+ * Represents an error specific to the configuration module.
+ *
+ * @template ErrorName - The name of the error.
+ * @template Payload - The payload type associated with the error.
+ */
+class ConfigError extends Error {
+    payload;
+    code;
+    /**
+     * Creates a new instance of the ConfigError class.
+     *
+     * @param name - The name of the error.
+     * @param message - The error message.
+     * @param payload - The payload associated with the error.
+     */
+    constructor(name, message, payload) {
+        super(message);
+        this.payload = payload;
+        this.name = name;
+        this.code = configErrors[name].code;
+    }
+}
+exports.ConfigError = ConfigError;
+function createConfigError(name, message, payload) {
+    return new ConfigError(name, message, payload);
+}
+exports.createConfigError = createConfigError;
+/**
+ * Checks if the given error is an instance of `ConfigError` with the specified error type.
+ * @param error - The error to check.
+ * @param errorName - The name of the error to check against.
+ * @returns `true` if the error is an instance of `ConfigError` with the specified error name, `false` otherwise.
+ */
+function isConfigError(error, errorName) {
+    if (!(error instanceof ConfigError)) {
+        return false;
+    }
+    return error.name === errorName && error.code === configErrors[errorName].code;
+}
+exports.isConfigError = isConfigError;
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAGA,MAAM,YAAY,GAAG;IACnB,qBAAqB,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAuB,EAAE;IACpE,qBAAqB,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAuB,EAAE;IACpE,iBAAiB,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAgF,EAAE;IACzH,gBAAgB,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAW,EAAE;IACnD,mBAAmB,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAA4B,EAAE;IACvE,kCAAkC,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAmE,EAAE;IAC7H,0BAA0B,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,EAAiE,EAAE;IACnH,8DAA8D;CACG,CAAC;AAOpE;;;;;GAKG;AACH,MAAa,WAAgG,SAAQ,KAAK;IAUnD;IATrD,IAAI,CAAkC;IAEtD;;;;;;OAMG;IACH,YAAmB,IAAe,EAAE,OAAe,EAAkB,OAA4B;QAC/F,KAAK,CAAC,OAAO,CAAC,CAAC;QADoD,YAAO,GAAP,OAAO,CAAqB;QAE/F,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;IACtC,CAAC;CACF;AAfD,kCAeC;AAED,SAAgB,iBAAiB,CAC/B,IAAe,EACf,OAAe,EACf,OAAgB;IAEhB,OAAO,IAAI,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AACjD,CAAC;AAND,8CAMC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAAuC,KAAc,EAAE,SAAoB;IACtG,IAAI,CAAC,CAAC,KAAK,YAAY,WAAW,CAAC,EAAE,CAAC;QACpC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC;AACjF,CAAC;AAND,sCAMC"}

package/dist/httpClient.d.ts

@@ -0,0 +1,4 @@
+import { Config, ServerCapabilities } from './types';
+export declare function getRemoteConfig(configName: string, version: number | 'latest'): Promise<Config>;
+export declare function getServerCapabilities(): Promise<ServerCapabilities>;
+//# sourceMappingURL=httpClient.d.ts.map

package/dist/httpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpClient.d.ts","sourceRoot":"","sources":["../src/httpClient.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAgCrD,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAkBrG;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAQzE"}

package/dist/httpClient.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServerCapabilities = exports.getRemoteConfig = void 0;
+const undici_1 = require("undici");
+const http_status_codes_1 = __importDefault(require("http-status-codes"));
+const options_1 = require("./options");
+const debug_1 = require("./utils/debug");
+const errors_1 = require("./errors");
+const debug = (0, debug_1.createDebug)('http');
+async function createHttpErrorPayload(res) {
+    return {
+        body: await res.body.text(),
+        headers: res.headers,
+        statusCode: res.statusCode,
+    };
+}
+async function requestWrapper(url, query) {
+    debug('Making request to %s', url);
+    try {
+        const res = await (0, undici_1.request)(url, { query });
+        if (res.statusCode > http_status_codes_1.default.NOT_FOUND) {
+            debug('Failed to fetch config. Status code: %d', res.statusCode);
+            throw (0, errors_1.createConfigError)('httpResponseError', 'Failed to fetch', await createHttpErrorPayload(res));
+        }
+        return res;
+    }
+    catch (error) {
+        if (error instanceof errors_1.ConfigError) {
+            throw error;
+        }
+        debug('An error occurred while making the request: %s', error.message);
+        throw (0, errors_1.createConfigError)('httpGeneralError', 'An error occurred while making the request', error);
+    }
+}
+async function getRemoteConfig(configName, version) {
+    debug('Fetching remote config %s@%s', configName, version);
+    const { configServerUrl } = (0, options_1.getOptions)();
+    const url = `${configServerUrl}/config/${configName}/${version}`;
+    const res = await requestWrapper(url, { shouldDereference: true });
+    if (res.statusCode === http_status_codes_1.default.BAD_REQUEST) {
+        debug('Invalid request to getConfig');
+        throw (0, errors_1.createConfigError)('httpResponseError', 'Invalid request to getConfig', await createHttpErrorPayload(res));
+    }
+    if (res.statusCode === http_status_codes_1.default.NOT_FOUND) {
+        debug('Config with given name and version was not found');
+        throw (0, errors_1.createConfigError)('httpResponseError', 'Config with given name and version was not found', await createHttpErrorPayload(res));
+    }
+    debug('Config fetched successfully');
+    return (await res.body.json());
+}
+exports.getRemoteConfig = getRemoteConfig;
+async function getServerCapabilities() {
+    debug('Fetching server capabilities');
+    const { configServerUrl } = (0, options_1.getOptions)();
+    const url = `${configServerUrl}/capabilities`;
+    const { body } = await requestWrapper(url);
+    debug('Server capabilities fetched successfully');
+    return (await body.json());
+}
+exports.getServerCapabilities = getServerCapabilities;
+//# sourceMappingURL=httpClient.js.map

package/dist/httpClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpClient.js","sourceRoot":"","sources":["../src/httpClient.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { ConfigOptions, ConfigInstance } from './types';
+export { config } from './config';
+export { ConfigErrors, isConfigError, ConfigError } from './errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigError = exports.isConfigError = exports.config = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_1.config; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "isConfigError", { enumerable: true, get: function () { return errors_1.isConfigError; } });
+Object.defineProperty(exports, "ConfigError", { enumerable: true, get: function () { return errors_1.ConfigError; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AACA,mCAAkC;AAAzB,gGAAA,MAAM,OAAA;AACf,mCAAoE;AAA7C,uGAAA,aAAa,OAAA;AAAE,qGAAA,WAAW,OAAA"}

package/dist/options.d.ts

@@ -0,0 +1,4 @@
+import { BaseOptions } from './types';
+export declare function initializeOptions(options: Partial<BaseOptions>): BaseOptions;
+export declare function getOptions(): BaseOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAiB,MAAM,SAAS,CAAC;AAwBrD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAoB5E;AAED,wBAAgB,UAAU,IAAI,WAAW,CAQxC"}

package/dist/options.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptions = exports.initializeOptions = void 0;
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const types_1 = require("./types");
+const validator_1 = require("./validator");
+const debug_1 = require("./utils/debug");
+const errors_1 = require("./errors");
+const debug = (0, debug_1.createDebug)('options');
+const envOptions = {
+    configName: process.env.CONFIG_NAME,
+    configServerUrl: process.env.CONFIG_SERVER_URL,
+    version: process.env.CONFIG_VERSION,
+    offlineMode: process.env.CONFIG_OFFLINE_MODE,
+    ignoreServerIsOlderVersionError: process.env.CONFIG_IGNORE_SERVER_IS_OLDER_VERSION_ERROR,
+};
+// in order to merge correctly the keys should not exist, undefined is not enough
+for (const key in envOptions) {
+    if (envOptions[key] === undefined) {
+        delete envOptions[key];
+    }
+}
+let baseOptions = undefined;
+function initializeOptions(options) {
+    debug('initializing options with %j and env %j', options, envOptions);
+    const mergedOptions = (0, deepmerge_1.default)(options, envOptions);
+    debug('merged options: %j', mergedOptions);
+    const [errors, validatedOptions] = (0, validator_1.validate)(validator_1.ajvOptionsValidator, types_1.optionsSchema, mergedOptions);
+    if (errors) {
+        debug('error validating options: %s', errors[0].message);
+        throw (0, errors_1.createConfigError)('optionValidationError', 'An error occurred while validating the given options. please check both arguments and environment variables', errors);
+    }
+    debug('options validated successfully');
+    baseOptions = validatedOptions;
+    return baseOptions;
+}
+exports.initializeOptions = initializeOptions;
+function getOptions() {
+    if (baseOptions === undefined) {
+        debug('Options were requested before being initialized');
+        throw new Error('Options not initialized');
+    }
+    debug('returning options');
+    return baseOptions;
+}
+exports.getOptions = getOptions;
+//# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":";;;;;;AAAA,0DAAkC;AAClC,mCAAqD;AACrD,2CAA4D;AAC5D,yCAA4C;AAC5C,qCAA6C;AAE7C,MAAM,KAAK,GAAG,IAAA,mBAAW,EAAC,SAAS,CAAC,CAAC;AAErC,MAAM,UAAU,GAA+C;IAC7D,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,WAAW;IACnC,eAAe,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB;IAC9C,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;IACnC,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,mBAAmB;IAC5C,+BAA+B,EAAE,OAAO,CAAC,GAAG,CAAC,2CAA2C;CACzF,CAAC;AAEF,iFAAiF;AACjF,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;IAC7B,IAAI,UAAU,CAAC,GAAwB,CAAC,KAAK,SAAS,EAAE,CAAC;QACvD,OAAO,UAAU,CAAC,GAAwB,CAAC,CAAC;IAC9C,CAAC;AACH,CAAC;AAED,IAAI,WAAW,GAA4B,SAAS,CAAC;AAErD,SAAgB,iBAAiB,CAAC,OAA6B;IAC7D,KAAK,CAAC,yCAAyC,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IACtE,MAAM,aAAa,GAAG,IAAA,mBAAS,EAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAErD,KAAK,CAAC,oBAAoB,EAAE,aAAa,CAAC,CAAC;IAE3C,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,IAAA,oBAAQ,EAAC,+BAAmB,EAAE,qBAAa,EAAE,aAAa,CAAC,CAAC;IAE/F,IAAI,MAAM,EAAE,CAAC;QACX,KAAK,CAAC,8BAA8B,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QACzD,MAAM,IAAA,0BAAiB,EACrB,uBAAuB,EACvB,6GAA6G,EAC7G,MAAM,CACP,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACxC,WAAW,GAAG,gBAA+B,CAAC;IAC9C,OAAO,WAAW,CAAC;AACrB,CAAC;AApBD,8CAoBC;AAED,SAAgB,UAAU;IACxB,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACzD,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAC3B,OAAO,WAAW,CAAC;AACrB,CAAC;AARD,gCAQC"}

package/dist/schemas.d.ts

@@ -0,0 +1,296 @@
+/// <reference types="node" />
+import $RefParser, { JSONSchema } from '@apidevtools/json-schema-ref-parser';
+declare const refParser: $RefParser<JSONSchema, {
+    parse?: {
+        [x: string]: boolean | {
+            name?: string | undefined;
+            order?: number | undefined;
+            allowEmpty?: boolean | undefined;
+            allowBOM?: boolean | undefined;
+            encoding?: BufferEncoding | undefined;
+            canParse?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            parse?: string | number | {} | undefined;
+        } | undefined;
+        json?: boolean | {
+            name?: string | undefined;
+            order?: number | undefined;
+            allowEmpty?: boolean | undefined;
+            allowBOM?: boolean | undefined;
+            encoding?: BufferEncoding | undefined;
+            canParse?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            parse?: string | number | {} | undefined;
+        } | undefined;
+        yaml?: boolean | {
+            name?: string | undefined;
+            order?: number | undefined;
+            allowEmpty?: boolean | undefined;
+            allowBOM?: boolean | undefined;
+            encoding?: BufferEncoding | undefined;
+            canParse?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            parse?: string | number | {} | undefined;
+        } | undefined;
+        binary?: boolean | {
+            name?: string | undefined;
+            order?: number | undefined;
+            allowEmpty?: boolean | undefined;
+            allowBOM?: boolean | undefined;
+            encoding?: BufferEncoding | undefined;
+            canParse?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            parse?: string | number | {} | undefined;
+        } | undefined;
+        text?: boolean | {
+            name?: string | undefined;
+            order?: number | undefined;
+            allowEmpty?: boolean | undefined;
+            allowBOM?: boolean | undefined;
+            encoding?: BufferEncoding | undefined;
+            canParse?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            parse?: string | number | {} | undefined;
+        } | undefined;
+    } | undefined;
+    resolve?: {
+        [x: string]: boolean | {
+            name?: string | undefined;
+            order?: number | undefined;
+            canRead?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            read?: string | object | {} | undefined;
+        } | {
+            headers?: ([(string | undefined)?, (string | undefined)?] | undefined)[] | {
+                [x: string]: string | undefined;
+            } | {
+                append?: {} | undefined;
+                delete?: {} | undefined;
+                get?: {} | undefined;
+                getSetCookie?: {} | undefined;
+                has?: {} | undefined;
+                set?: {} | undefined;
+                forEach?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+            } | null | undefined;
+            timeout?: number | undefined;
+            redirects?: number | undefined;
+            withCredentials?: boolean | undefined;
+            name?: string | undefined;
+            order?: number | undefined;
+            canRead?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            read?: string | object | {} | undefined;
+        } | undefined;
+        external?: boolean | undefined;
+        file?: boolean | {
+            name?: string | undefined;
+            order?: number | undefined;
+            canRead?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            read?: string | object | {} | undefined;
+        } | undefined;
+        http?: boolean | {
+            headers?: ([(string | undefined)?, (string | undefined)?] | undefined)[] | {
+                [x: string]: string | undefined;
+            } | {
+                append?: {} | undefined;
+                delete?: {} | undefined;
+                get?: {} | undefined;
+                getSetCookie?: {} | undefined;
+                has?: {} | undefined;
+                set?: {} | undefined;
+                forEach?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+            } | null | undefined;
+            timeout?: number | undefined;
+            redirects?: number | undefined;
+            withCredentials?: boolean | undefined;
+            name?: string | undefined;
+            order?: number | undefined;
+            canRead?: string | boolean | {
+                exec?: {} | undefined;
+                test?: {} | undefined;
+                readonly source?: string | undefined;
+                readonly global?: boolean | undefined;
+                readonly ignoreCase?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                lastIndex?: number | undefined;
+                compile?: {} | undefined;
+                readonly flags?: string | undefined;
+                readonly sticky?: boolean | undefined;
+                readonly unicode?: boolean | undefined;
+                readonly dotAll?: boolean | undefined;
+                readonly hasIndices?: boolean | undefined;
+                [Symbol.match]?: {} | undefined;
+                [Symbol.replace]?: {} | undefined;
+                [Symbol.search]?: {} | undefined;
+                [Symbol.split]?: {} | undefined;
+                [Symbol.matchAll]?: {} | undefined;
+            } | (string | undefined)[] | {} | undefined;
+            read?: string | object | {} | undefined;
+        } | undefined;
+    } | undefined;
+    continueOnError?: boolean | undefined;
+    dereference?: {
+        circular?: boolean | "ignore" | undefined;
+        excludedPathMatcher?: {} | undefined;
+        onDereference?: {} | undefined;
+        externalReferenceResolution?: "relative" | "root" | undefined;
+    } | undefined;
+    mutateInputSchema?: boolean | undefined;
+    timeoutMs?: number | undefined;
+}>;
+export declare function loadSchema(schema: JSONSchema): ReturnType<typeof refParser.dereference>;
+export {};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":";AAEA,OAAO,UAAU,EAAE,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAO7E,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAmB,CAAC;AAanC,wBAAsB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,WAAW,CAAC,CAiB7F"}

package/dist/schemas.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSchema = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const json_schema_ref_parser_1 = __importDefault(require("@apidevtools/json-schema-ref-parser"));
+const constants_1 = require("./constants");
+const debug_1 = require("./utils/debug");
+const errors_1 = require("./errors");
+const debug = (0, debug_1.createDebug)('schemas');
+const refParser = new json_schema_ref_parser_1.default();
+function loadSpecificSchema(relativePath) {
+    debug('loading specific schema at path %s', relativePath);
+    const fullPath = node_path_1.default.join(constants_1.SCHEMA_BASE_PATH, relativePath + '.schema.json');
+    if (!node_fs_1.default.existsSync(fullPath)) {
+        throw (0, errors_1.createConfigError)(`schemaNotFoundError`, `Schema not found at path`, { schemaPath: fullPath });
+    }
+    return JSON.parse(node_fs_1.default.readFileSync(fullPath, { encoding: 'utf-8' }));
+}
+async function loadSchema(schema) {
+    debug('loading schema id %s', schema.$id);
+    const dereferencedSchema = await refParser.dereference(schema, {
+        dereference: { circular: false },
+        resolve: {
+            mapcolonies: {
+                canRead: /^https:\/\/mapcolonies.com\/.*/,
+                order: 1,
+                read: (file) => {
+                    const subPath = file.url.split(constants_1.SCHEMA_DOMAIN)[1];
+                    return loadSpecificSchema(subPath);
+                },
+            },
+        },
+    });
+    return dereferencedSchema;
+}
+exports.loadSchema = loadSchema;
+//# sourceMappingURL=schemas.js.map

package/dist/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":";;;;;;AAAA,0DAA6B;AAC7B,sDAAyB;AACzB,iGAA6E;AAC7E,2CAA8D;AAC9D,yCAA4C;AAC5C,qCAA6C;AAE7C,MAAM,KAAK,GAAG,IAAA,mBAAW,EAAC,SAAS,CAAC,CAAC;AAErC,MAAM,SAAS,GAAG,IAAI,gCAAU,EAAE,CAAC;AAEnC,SAAS,kBAAkB,CAAC,YAAoB;IAC9C,KAAK,CAAC,oCAAoC,EAAE,YAAY,CAAC,CAAC;IAC1D,MAAM,QAAQ,GAAG,mBAAI,CAAC,IAAI,CAAC,4BAAgB,EAAE,YAAY,GAAG,cAAc,CAAC,CAAC;IAE5E,IAAI,CAAC,iBAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAA,0BAAiB,EAAC,qBAAqB,EAAE,0BAA0B,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC;IACvG,CAAC;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAe,CAAC;AACpF,CAAC;AAEM,KAAK,UAAU,UAAU,CAAC,MAAkB;IACjD,KAAK,CAAC,sBAAsB,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1C,MAAM,kBAAkB,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE;QAC7D,WAAW,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE;QAChC,OAAO,EAAE;YACP,WAAW,EAAE;gBACX,OAAO,EAAE,gCAAgC;gBACzC,KAAK,EAAE,CAAC;gBACR,IAAI,EAAE,CAAC,IAAsD,EAAE,EAAE;oBAC/D,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,yBAAa,CAAC,CAAC,CAAC,CAAC,CAAC;oBAEjD,OAAO,kBAAkB,CAAC,OAAO,CAAC,CAAC;gBACrC,CAAC;aACF;SACF;KACF,CAAC,CAAC;IACH,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAjBD,gCAiBC"}