@eik/core 1.3.53 → 1.3.55

package/types/handlers/map.put.d.ts

@@ -0,0 +1,78 @@
+export default MapPut;
+export type MapPutOptions = {
+    mapMaxFileSize?: number;
+    cacheControl?: string;
+    /**
+     * List of key-value pairs [hostname, organization]
+     */
+    organizations?: Array<[string, string]>;
+    sink?: import("@eik/sink").default;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+/**
+ * @typedef {object} MapPutOptions
+ * @property {number} [mapMaxFileSize]
+ * @property {string} [cacheControl]
+ * @property {Array<[string, string]>} [organizations] List of key-value pairs [hostname, organization]
+ * @property {import("@eik/sink").default} [sink]
+ * @property {import("abslog").AbstractLoggerOptions} [logger]
+ */
+declare const MapPut: {
+    new ({ mapMaxFileSize, organizations, cacheControl, logger, sink, }?: MapPutOptions): {
+        _mapMaxFileSize: number;
+        _organizations: [string, string][];
+        _cacheControl: string;
+        _sink: import("@eik/sink").default;
+        _log: abslog.ValidLogger;
+        _metrics: Metrics;
+        _histogram: Metrics.MetricsHistogram;
+        _orgRegistry: Map<string, string>;
+        readonly metrics: Metrics;
+        _parser(incoming: any): Promise<any>;
+        _handleFile({ fieldname, file, path }: {
+            fieldname: any;
+            file: any;
+            path: any;
+        }): Promise<string>;
+        _readVersions(incoming: any): Promise<{
+            _versions: Map<any, any>;
+            _type: string;
+            _name: string;
+            _org: string;
+            readonly versions: [any, any][];
+            readonly type: string;
+            readonly name: string;
+            readonly org: string;
+            setVersion(version: any, integrity: any): void;
+            getVersion(major: any): any;
+            check(version: any): boolean;
+            toJSON(): {
+                versions: [any, any][];
+                type: string;
+                name: string;
+                org: string;
+            };
+            readonly [Symbol.toStringTag]: string;
+        }>;
+        _writeVersions(incoming: any, versions: any): Promise<void>;
+        handler(req: any, user: any, name: any, version: any): Promise<{
+            _cacheControl: string;
+            _statusCode: number;
+            _mimeType: string;
+            _location: string;
+            _stream: any;
+            _body: any;
+            _etag: string;
+            cacheControl: string;
+            statusCode: number;
+            location: string;
+            mimeType: string;
+            stream: any;
+            body: any;
+            etag: string;
+            readonly [Symbol.toStringTag]: string;
+        }>;
+    };
+};
+import abslog from "abslog";
+import Metrics from "@metrics/client";

package/types/handlers/pkg.get.d.ts

@@ -0,0 +1,51 @@
+export default PkgGet;
+export type PkgGetOptions = {
+    etag?: boolean;
+    cacheControl?: string;
+    /**
+     * List of key-value pairs [hostname, organization]
+     */
+    organizations?: Array<[string, string]>;
+    sink?: import("@eik/sink").default;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+/**
+ * @typedef {object} PkgGetOptions
+ * @property {boolean} [etag]
+ * @property {string} [cacheControl]
+ * @property {Array<[string, string]>} [organizations] List of key-value pairs [hostname, organization]
+ * @property {import("@eik/sink").default} [sink]
+ * @property {import("abslog").AbstractLoggerOptions} [logger]
+ */
+declare const PkgGet: {
+    new ({ organizations, cacheControl, logger, sink, etag }?: PkgGetOptions): {
+        _organizations: [string, string][];
+        _cacheControl: string;
+        _sink: import("@eik/sink").default;
+        _etag: boolean;
+        _log: abslog.ValidLogger;
+        _metrics: Metrics;
+        _histogram: Metrics.MetricsHistogram;
+        _orgRegistry: Map<string, string>;
+        readonly metrics: Metrics;
+        handler(req: any, type: any, name: any, version: any, extra: any): Promise<{
+            _cacheControl: string;
+            _statusCode: number;
+            _mimeType: string;
+            _location: string;
+            _stream: any;
+            _body: any;
+            _etag: string;
+            cacheControl: string;
+            statusCode: number;
+            location: string;
+            mimeType: string;
+            stream: any;
+            body: any;
+            etag: string;
+            readonly [Symbol.toStringTag]: string;
+        }>;
+    };
+};
+import abslog from "abslog";
+import Metrics from "@metrics/client";

package/types/handlers/pkg.log.d.ts

@@ -0,0 +1,51 @@
+export default PkgLog;
+export type PkgLogOptions = {
+    etag?: boolean;
+    cacheControl?: string;
+    /**
+     * List of key-value pairs [hostname, organization]
+     */
+    organizations?: Array<[string, string]>;
+    sink?: import("@eik/sink").default;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+/**
+ * @typedef {object} PkgLogOptions
+ * @property {boolean} [etag]
+ * @property {string} [cacheControl]
+ * @property {Array<[string, string]>} [organizations] List of key-value pairs [hostname, organization]
+ * @property {import("@eik/sink").default} [sink]
+ * @property {import("abslog").AbstractLoggerOptions} [logger]
+ */
+declare const PkgLog: {
+    new ({ organizations, cacheControl, logger, sink, etag }?: PkgLogOptions): {
+        _organizations: [string, string][];
+        _cacheControl: string;
+        _sink: import("@eik/sink").default;
+        _etag: boolean;
+        _log: abslog.ValidLogger;
+        _metrics: Metrics;
+        _histogram: Metrics.MetricsHistogram;
+        _orgRegistry: Map<string, string>;
+        readonly metrics: Metrics;
+        handler(req: any, type: any, name: any, version: any): Promise<{
+            _cacheControl: string;
+            _statusCode: number;
+            _mimeType: string;
+            _location: string;
+            _stream: any;
+            _body: any;
+            _etag: string;
+            cacheControl: string;
+            statusCode: number;
+            location: string;
+            mimeType: string;
+            stream: any;
+            body: any;
+            etag: string;
+            readonly [Symbol.toStringTag]: string;
+        }>;
+    };
+};
+import abslog from "abslog";
+import Metrics from "@metrics/client";

package/types/handlers/pkg.put.d.ts

@@ -0,0 +1,107 @@
+export default PkgPut;
+export type PkgPutOptions = {
+    pkgMaxFileSize?: number;
+    cacheControl?: string;
+    /**
+     * List of key-value pairs [hostname, organization]
+     */
+    organizations?: Array<[string, string]>;
+    sink?: import("@eik/sink").default;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+/**
+ * @typedef {object} PkgPutOptions
+ * @property {number} [pkgMaxFileSize=10000000]
+ * @property {string} [cacheControl]
+ * @property {Array<[string, string]>} [organizations] List of key-value pairs [hostname, organization]
+ * @property {import("@eik/sink").default} [sink]
+ * @property {import("abslog").AbstractLoggerOptions} [logger]
+ */
+declare const PkgPut: {
+    new ({ pkgMaxFileSize, organizations, cacheControl, logger, sink, }?: PkgPutOptions): {
+        _pkgMaxFileSize: number;
+        _organizations: [string, string][];
+        _cacheControl: string;
+        _sink: import("@eik/sink").default;
+        _log: abslog.ValidLogger;
+        _metrics: Metrics;
+        _histogram: Metrics.MetricsHistogram;
+        _orgRegistry: Map<string, string>;
+        _multipart: {
+            _pkgMaxFileSize: number;
+            _legalFields: string[];
+            _legalFiles: string[];
+            _sink: import("@eik/sink").default;
+            _log: abslog.ValidLogger;
+            parse(incoming: any): Promise<any>;
+            _handleField({ name, value }: {
+                name: any;
+                value: any;
+            }): {
+                _value: string;
+                _name: string;
+                readonly value: string;
+                readonly name: string;
+                toJSON(): {
+                    value: string;
+                    name: string;
+                };
+                readonly [Symbol.toStringTag]: string;
+            };
+            _handleFile({ fieldname, file, filename, incoming }: {
+                fieldname: any;
+                file: any;
+                filename: any;
+                incoming: any;
+            }): Promise<any>;
+            _persistFile({ incoming, entry }: {
+                incoming: any;
+                entry: any;
+            }): Promise<any>;
+            readonly [Symbol.toStringTag]: string;
+        };
+        readonly metrics: Metrics;
+        _parser(incoming: any): Promise<any>;
+        _readVersions(incoming: any): Promise<{
+            _versions: Map<any, any>;
+            _type: string;
+            _name: string;
+            _org: string;
+            readonly versions: [any, any][];
+            readonly type: string;
+            readonly name: string;
+            readonly org: string;
+            setVersion(version: any, integrity: any): void;
+            getVersion(major: any): any;
+            check(version: any): boolean;
+            toJSON(): {
+                versions: [any, any][];
+                type: string;
+                name: string;
+                org: string;
+            };
+            readonly [Symbol.toStringTag]: string;
+        }>;
+        _readVersion(incoming: any): Promise<boolean>;
+        _writeVersions(incoming: any, versions: any): Promise<void>;
+        handler(req: any, user: any, type: any, name: any, version: any): Promise<{
+            _cacheControl: string;
+            _statusCode: number;
+            _mimeType: string;
+            _location: string;
+            _stream: any;
+            _body: any;
+            _etag: string;
+            cacheControl: string;
+            statusCode: number;
+            location: string;
+            mimeType: string;
+            stream: any;
+            body: any;
+            etag: string;
+            readonly [Symbol.toStringTag]: string;
+        }>;
+    };
+};
+import abslog from "abslog";
+import Metrics from "@metrics/client";

package/types/handlers/versions.get.d.ts

@@ -0,0 +1,48 @@
+export default VersionsGet;
+export type VersionsGetOptions = {
+    cacheControl?: string;
+    etag?: boolean;
+    organizations?: Array<[string, string]>;
+    sink?: import("@eik/sink").default;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+/**
+ * @typedef {object} VersionsGetOptions
+ * @property {string} [cacheControl="no-cache"]
+ * @property {boolean} [etag=true]
+ * @property {Array<[string, string]>} [organizations]
+ * @property {import("@eik/sink").default} [sink]
+ * @property {import("abslog").AbstractLoggerOptions} [logger]
+ */
+declare const VersionsGet: {
+    new ({ organizations, cacheControl, logger, sink, etag }?: VersionsGetOptions): {
+        _organizations: [string, string][];
+        _cacheControl: string;
+        _sink: import("@eik/sink").default;
+        _etag: boolean;
+        _log: abslog.ValidLogger;
+        _metrics: Metrics;
+        _histogram: Metrics.MetricsHistogram;
+        _orgRegistry: Map<string, string>;
+        readonly metrics: Metrics;
+        handler(req: any, type: any, name: any): Promise<{
+            _cacheControl: string;
+            _statusCode: number;
+            _mimeType: string;
+            _location: string;
+            _stream: any;
+            _body: any;
+            _etag: string;
+            cacheControl: string;
+            statusCode: number;
+            location: string;
+            mimeType: string;
+            stream: any;
+            body: any;
+            etag: string;
+            readonly [Symbol.toStringTag]: string;
+        }>;
+    };
+};
+import abslog from "abslog";
+import Metrics from "@metrics/client";

package/types/main.d.ts

@@ -0,0 +1,44 @@
+declare namespace _default {
+    export { HealthCheck };
+    export { http };
+    export { sink };
+    export { prop };
+}
+export default _default;
+import HealthCheck from "./utils/healthcheck.js";
+declare namespace http {
+    export { VersionsGet };
+    export { AliasPost };
+    export { AliasPut };
+    export { AliasGet };
+    export { AliasDel };
+    export { AuthPost };
+    export { PkgLog };
+    export { PkgGet };
+    export { PkgPut };
+    export { MapGet };
+    export { MapPut };
+}
+declare namespace sink {
+    export { TEST };
+    export { MEM };
+    export { FS };
+}
+declare namespace prop {
+    let base_auth: string;
+    let base_map: string;
+    let base_pkg: string;
+    let base_npm: string;
+}
+import VersionsGet from "./handlers/versions.get.js";
+import AliasPost from "./handlers/alias.post.js";
+import AliasPut from "./handlers/alias.put.js";
+import AliasGet from "./handlers/alias.get.js";
+import AliasDel from "./handlers/alias.delete.js";
+import AuthPost from "./handlers/auth.post.js";
+import PkgLog from "./handlers/pkg.log.js";
+import PkgGet from "./handlers/pkg.get.js";
+import PkgPut from "./handlers/pkg.put.js";
+import MapGet from "./handlers/map.get.js";
+import MapPut from "./handlers/map.put.js";
+import TEST from "./sinks/test.js";

package/types/multipart/form-field.d.ts

@@ -0,0 +1,17 @@
+export default FormField;
+declare const FormField: {
+    new ({ value, name }?: {
+        value?: string;
+        name?: string;
+    }): {
+        _value: string;
+        _name: string;
+        readonly value: string;
+        readonly name: string;
+        toJSON(): {
+            value: string;
+            name: string;
+        };
+        readonly [Symbol.toStringTag]: string;
+    };
+};

package/types/multipart/form-file.d.ts

@@ -0,0 +1,17 @@
+export default FormFile;
+declare const FormFile: {
+    new ({ value, name }?: {
+        value?: any[];
+        name?: string;
+    }): {
+        _value: any[];
+        _name: string;
+        readonly value: any[];
+        readonly name: string;
+        toJSON(): {
+            value: any[];
+            name: string;
+        };
+        readonly [Symbol.toStringTag]: string;
+    };
+};

package/types/multipart/parser.d.ts

@@ -0,0 +1,52 @@
+export default MultipartParser;
+export type MultipartParserOptions = {
+    pkgMaxFileSize?: number;
+    legalFields?: string[];
+    legalFiles?: string[];
+    sink?: import("@eik/sink").default;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+/**
+ * @typedef {object} MultipartParserOptions
+ * @property {number} [pkgMaxFileSize=10000000]
+ * @property {string[]} [legalFields]
+ * @property {string[]} [legalFiles]
+ * @property {import("@eik/sink").default} [sink]
+ * @property {import("abslog").AbstractLoggerOptions} [logger]
+ */
+declare const MultipartParser: {
+    new ({ pkgMaxFileSize, legalFields, legalFiles, logger, sink }?: MultipartParserOptions): {
+        _pkgMaxFileSize: number;
+        _legalFields: string[];
+        _legalFiles: string[];
+        _sink: import("@eik/sink").default;
+        _log: abslog.ValidLogger;
+        parse(incoming: any): Promise<any>;
+        _handleField({ name, value }: {
+            name: any;
+            value: any;
+        }): {
+            _value: string;
+            _name: string;
+            readonly value: string;
+            readonly name: string;
+            toJSON(): {
+                value: string;
+                name: string;
+            };
+            readonly [Symbol.toStringTag]: string;
+        };
+        _handleFile({ fieldname, file, filename, incoming }: {
+            fieldname: any;
+            file: any;
+            filename: any;
+            incoming: any;
+        }): Promise<any>;
+        _persistFile({ incoming, entry }: {
+            incoming: any;
+            entry: any;
+        }): Promise<any>;
+        readonly [Symbol.toStringTag]: string;
+    };
+};
+import abslog from "abslog";

package/types/sinks/mem-entry.d.ts

@@ -0,0 +1,15 @@
+export default Entry;
+declare const Entry: {
+    new ({ mimeType, payload }?: {
+        mimeType?: string;
+        payload?: any[];
+    }): {
+        _mimeType: string;
+        _payload: any[];
+        _hash: string;
+        readonly mimeType: string;
+        readonly payload: any[];
+        readonly hash: string;
+        readonly [Symbol.toStringTag]: string;
+    };
+};

package/types/sinks/test.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @deprecated Use eik/sink-memory or implement your own. This class will be removed in a future version of core.
+ */
+export default class SinkTest extends Sink {
+    constructor({ rootPath }?: {
+        rootPath?: string;
+    });
+    _rootPath: string;
+    _metrics: Metrics;
+    _state: Map<any, any>;
+    _counter: Metrics.MetricsCounter;
+    _writeDelayResolve: (a?: number) => number;
+    _writeDelayChunks: (a?: number) => number;
+    set(filePath: any, payload: any): void;
+    get(filePath: any): any;
+    dump(): [any, any][];
+    load(items: any): void;
+    /**
+     * @param {(count: number) => number} fn
+     */
+    set writeDelayResolve(fn: (count: number) => number);
+    /**
+     * @param {(count: number) => number} fn
+     */
+    set writeDelayChunks(fn: (count: number) => number);
+    write(filePath: any, contentType: any): Promise<any>;
+    read(filePath: any): Promise<any>;
+    delete(filePath: any): Promise<any>;
+    exist(filePath: any): Promise<any>;
+}
+import Sink from "@eik/sink";
+import Metrics from "@metrics/client";

package/types/utils/defaults.d.ts

@@ -0,0 +1,9 @@
+export default config;
+declare namespace config {
+    let authKey: string;
+    let pkgMaxFileSize: number;
+    let mapMaxFileSize: number;
+    let sinkFsRootPath: string;
+    let etag: boolean;
+    let organizations: Array<[string, string]>;
+}

package/types/utils/globals.d.ts

@@ -0,0 +1,8 @@
+export default globals;
+declare namespace globals {
+    let BASE_AUTHENTICATION: string;
+    let BASE_IMPORT_MAPS: string;
+    let BASE_PACKAGES: string;
+    let BASE_NPM: string;
+    let ROOT: string;
+}

package/types/utils/healthcheck.d.ts

@@ -0,0 +1,24 @@
+export default HealthCheck;
+export type HealthCheckOptions = {
+    sink?: import("@eik/sink").default;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+/**
+ * @typedef {object} HealthCheckOptions
+ * @property {import("@eik/sink").default} [sink]
+ * @property {import("abslog").AbstractLoggerOptions} [logger]
+ */
+declare const HealthCheck: {
+    new ({ sink, logger }?: HealthCheckOptions): {
+        _sink: import("@eik/sink").default;
+        _name: string;
+        _log: abslog.ValidLogger;
+        _write(): Promise<any>;
+        _read(): Promise<any>;
+        _delete(): Promise<void>;
+        _exist(): Promise<void>;
+        check(): Promise<boolean>;
+        readonly [Symbol.toStringTag]: string;
+    };
+};
+import abslog from "abslog";

package/types/utils/path-builders-fs.d.ts

@@ -0,0 +1,41 @@
+export function createFilePathToPackage({ org, type, name, version, }?: {
+    org?: string;
+    type?: string;
+    name?: string;
+    version?: string;
+}): string;
+export function createFilePathToAsset({ org, type, name, version, asset, }?: {
+    org?: string;
+    type?: string;
+    name?: string;
+    version?: string;
+    asset?: string;
+}): string;
+export function createFilePathToImportMap({ org, name, version, }?: {
+    org?: string;
+    name?: string;
+    version?: string;
+}): string;
+export function createFilePathToAlias({ org, type, name, alias, }?: {
+    org?: string;
+    type?: string;
+    name?: string;
+    alias?: string;
+}): string;
+export function createFilePathToVersion({ org, type, name }?: {
+    org?: string;
+    type?: string;
+    name?: string;
+}): string;
+export function createFilePathToAliasOrigin({ org, type, name, version, }?: {
+    org?: string;
+    type?: string;
+    name?: string;
+    version?: string;
+}): string;
+export function createFilePathToEikJson({ org, type, name, version, }?: {
+    org?: string;
+    type?: string;
+    name?: string;
+    version?: string;
+}): string;

package/types/utils/path-builders-uri.d.ts

@@ -0,0 +1,26 @@
+export function createURIPathToPkgLog({ type, name, version }?: {
+    type?: string;
+    name?: string;
+    version?: string;
+}): string;
+export function createURIPathToAsset({ type, name, version, asset, }?: {
+    type?: string;
+    name?: string;
+    version?: string;
+    asset?: string;
+}): string;
+export function createURIPathToImportMap({ name, version }?: {
+    name?: string;
+    version?: string;
+}): string;
+export function createURIToAlias({ type, name, alias }?: {
+    type?: string;
+    name?: string;
+    alias?: string;
+}): string;
+export function createURIToTargetOfAlias({ type, name, version, extra, }?: {
+    type?: string;
+    name?: string;
+    version?: string;
+    extra?: string;
+}): string;

package/types/utils/utils.d.ts

@@ -0,0 +1,6 @@
+export function readJSON(sink: any, path: any): Promise<any>;
+export function writeJSON(sink: any, path: any, obj: any, contentType: any): Promise<any>;
+export function streamCollector(from: any): Promise<any>;
+export function etagFromFsStat(stat: any): string;
+export function decodeUriComponent(value: any): any;
+export function readEikJson(sink: any, path: any): any;