npm - vovk - Versions diffs - 0.0.0 → 0.1.1 - Mend

vovk 0.0.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/HttpException.d.ts +6 -0
package/HttpException.js +13 -0
package/README.md +830 -1
package/Segment.d.ts +31 -0
package/Segment.js +132 -0
package/StreamResponse.d.ts +16 -0
package/StreamResponse.js +41 -0
package/client/clientizeController.d.ts +3 -0
package/client/clientizeController.js +67 -0
package/client/defaultFetcher.d.ts +7 -0
package/client/defaultFetcher.js +55 -0
package/client/defaultStreamFetcher.d.ts +4 -0
package/client/defaultStreamFetcher.js +103 -0
package/client/index.d.ts +5 -0
package/client/index.js +7 -0
package/client/types.d.ts +69 -0
package/client/types.js +2 -0
package/createDecorator.d.ts +9 -0
package/createDecorator.js +41 -0
package/createSegment.d.ts +67 -0
package/createSegment.js +171 -0
package/index.d.ts +62 -0
package/index.js +16 -0
package/package.json +67 -6
package/tsconfig.tsbuildinfo +1 -0
package/types.d.ts +140 -0
package/types.js +65 -0
package/worker/index.d.ts +3 -0
package/worker/index.js +7 -0
package/worker/promisifyWorker.d.ts +2 -0
package/worker/promisifyWorker.js +118 -0
package/worker/types.d.ts +22 -0
package/worker/types.js +2 -0
package/worker/worker.d.ts +1 -0
package/worker/worker.js +47 -0

package/types.d.ts ADDED Viewed

@@ -0,0 +1,140 @@
+import type { NextRequest } from 'next/server';
+export type _KnownAny = any;
+export type _ErrorResponseBody = {
+    statusCode: _HttpStatus;
+    message: string;
+    isError: true;
+};
+export type _HandlerMetadata = {
+    path: string;
+    httpMethod: _HttpMethod;
+    clientValidators?: {
+        query?: _KnownAny;
+        body?: _KnownAny;
+    };
+};
+export type _VovkControllerMetadata = {
+    controllerName: string;
+    _prefix?: string;
+    _handlers: Record<string, _HandlerMetadata>;
+};
+export type _HandlerMetadataJson = {
+    path: string;
+    httpMethod: string;
+    clientValidators?: {
+        query?: _KnownAny;
+        body?: _KnownAny;
+    };
+};
+export type _VovkControllerMetadataJson = {
+    controllerName: string;
+    _prefix?: string;
+    _handlers: Record<string, _HandlerMetadataJson>;
+};
+export type _VovkWorkerMetadata = {
+    workerName: string;
+    _handlers: Record<string, {
+        isGenerator?: true;
+    }>;
+};
+export type _VovkControllerInternal = _VovkControllerMetadata & {
+    _activated?: true;
+    _onError?: (err: Error) => void;
+};
+export type _VovkController = Function & _VovkControllerInternal & {
+    [key: string]: unknown;
+};
+export type _VovkWorker = Function & _VovkWorkerMetadata & {
+    [key: string]: unknown;
+};
+export type _RouteHandler = (req: NextRequest, params: Record<string, string>) => Response | Promise<Response>;
+export interface _VovkRequest<BODY = undefined, QUERY extends Record<string, string> | undefined = undefined> extends Omit<NextRequest, 'json' | 'nextUrl'> {
+    json: () => Promise<BODY>;
+    nextUrl: Omit<NextRequest['nextUrl'], 'searchParams'> & {
+        searchParams: Omit<NextRequest['nextUrl']['searchParams'], 'get'> & {
+            get: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY];
+            readonly __queryType: QUERY;
+        };
+    };
+}
+export type _ControllerStaticMethod<REQ extends _VovkRequest<undefined, _KnownAny> = _VovkRequest<undefined, Record<string, string>>, PARAMS extends {
+    [key: string]: string;
+} = _KnownAny> = ((req: REQ, params: PARAMS) => unknown) & {
+    _controller?: _VovkController;
+};
+export type _VovkBody<T extends _ControllerStaticMethod<REQ, PARAMS>, REQ extends _VovkRequest<undefined, _KnownAny> = Parameters<T>[0], PARAMS extends {
+    [key: string]: string;
+} = _KnownAny> = Awaited<ReturnType<Parameters<T>[0]['json']>>;
+export type _VovkQuery<T extends _ControllerStaticMethod<REQ, PARAMS>, REQ extends _VovkRequest<undefined, _KnownAny> = Parameters<T>[0], PARAMS extends {
+    [key: string]: string;
+} = _KnownAny> = Parameters<T>[0]['nextUrl']['searchParams']['__queryType'];
+export type _VovkParams<T extends _ControllerStaticMethod<REQ, PARAMS>, REQ extends _VovkRequest<undefined, _KnownAny> = Parameters<T>[0], PARAMS extends {
+    [key: string]: string;
+} = _KnownAny> = Parameters<T>[1];
+export type _VovkReturnType<T extends _ControllerStaticMethod<REQ, PARAMS>, REQ extends _VovkRequest<undefined, _KnownAny> = Parameters<T>[0], PARAMS extends {
+    [key: string]: string;
+} = _KnownAny> = Awaited<ReturnType<T>>;
+export type _StreamAbortMessage = {
+    isError: true;
+    reason: _KnownAny;
+};
+export declare enum _HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS"
+}
+export declare enum _HttpStatus {
+    NULL = 0,
+    CONTINUE = 100,
+    SWITCHING_PROTOCOLS = 101,
+    PROCESSING = 102,
+    EARLYHINTS = 103,
+    OK = 200,
+    CREATED = 201,
+    ACCEPTED = 202,
+    NON_AUTHORITATIVE_INFORMATION = 203,
+    NO_CONTENT = 204,
+    RESET_CONTENT = 205,
+    PARTIAL_CONTENT = 206,
+    AMBIGUOUS = 300,
+    MOVED_PERMANENTLY = 301,
+    FOUND = 302,
+    SEE_OTHER = 303,
+    NOT_MODIFIED = 304,
+    TEMPORARY_REDIRECT = 307,
+    PERMANENT_REDIRECT = 308,
+    BAD_REQUEST = 400,
+    UNAUTHORIZED = 401,
+    PAYMENT_REQUIRED = 402,
+    FORBIDDEN = 403,
+    NOT_FOUND = 404,
+    METHOD_NOT_ALLOWED = 405,
+    NOT_ACCEPTABLE = 406,
+    PROXY_AUTHENTICATION_REQUIRED = 407,
+    REQUEST_TIMEOUT = 408,
+    CONFLICT = 409,
+    GONE = 410,
+    LENGTH_REQUIRED = 411,
+    PRECONDITION_FAILED = 412,
+    PAYLOAD_TOO_LARGE = 413,
+    URI_TOO_LONG = 414,
+    UNSUPPORTED_MEDIA_TYPE = 415,
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+    EXPECTATION_FAILED = 417,
+    I_AM_A_TEAPOT = 418,
+    MISDIRECTED = 421,
+    UNPROCESSABLE_ENTITY = 422,
+    FAILED_DEPENDENCY = 424,
+    PRECONDITION_REQUIRED = 428,
+    TOO_MANY_REQUESTS = 429,
+    INTERNAL_SERVER_ERROR = 500,
+    NOT_IMPLEMENTED = 501,
+    BAD_GATEWAY = 502,
+    SERVICE_UNAVAILABLE = 503,
+    GATEWAY_TIMEOUT = 504,
+    HTTP_VERSION_NOT_SUPPORTED = 505
+}

package/types.js ADDED Viewed

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._HttpStatus = exports._HttpMethod = void 0;
+var _HttpMethod;
+(function (_HttpMethod) {
+    _HttpMethod["GET"] = "GET";
+    _HttpMethod["POST"] = "POST";
+    _HttpMethod["PUT"] = "PUT";
+    _HttpMethod["PATCH"] = "PATCH";
+    _HttpMethod["DELETE"] = "DELETE";
+    _HttpMethod["HEAD"] = "HEAD";
+    _HttpMethod["OPTIONS"] = "OPTIONS";
+})(_HttpMethod || (exports._HttpMethod = _HttpMethod = {}));
+var _HttpStatus;
+(function (_HttpStatus) {
+    _HttpStatus[_HttpStatus["NULL"] = 0] = "NULL";
+    _HttpStatus[_HttpStatus["CONTINUE"] = 100] = "CONTINUE";
+    _HttpStatus[_HttpStatus["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+    _HttpStatus[_HttpStatus["PROCESSING"] = 102] = "PROCESSING";
+    _HttpStatus[_HttpStatus["EARLYHINTS"] = 103] = "EARLYHINTS";
+    _HttpStatus[_HttpStatus["OK"] = 200] = "OK";
+    _HttpStatus[_HttpStatus["CREATED"] = 201] = "CREATED";
+    _HttpStatus[_HttpStatus["ACCEPTED"] = 202] = "ACCEPTED";
+    _HttpStatus[_HttpStatus["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+    _HttpStatus[_HttpStatus["NO_CONTENT"] = 204] = "NO_CONTENT";
+    _HttpStatus[_HttpStatus["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+    _HttpStatus[_HttpStatus["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+    _HttpStatus[_HttpStatus["AMBIGUOUS"] = 300] = "AMBIGUOUS";
+    _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["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_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_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["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+    _HttpStatus[_HttpStatus["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+    _HttpStatus[_HttpStatus["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+    _HttpStatus[_HttpStatus["MISDIRECTED"] = 421] = "MISDIRECTED";
+    _HttpStatus[_HttpStatus["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+    _HttpStatus[_HttpStatus["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+    _HttpStatus[_HttpStatus["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+    _HttpStatus[_HttpStatus["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+    _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 || (exports._HttpStatus = _HttpStatus = {}));

package/worker/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { _worker as worker } from './worker';
+import { _promisifyWorker as promisifyWorker } from './promisifyWorker';
+export { worker, promisifyWorker };

package/worker/index.js ADDED Viewed

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promisifyWorker = exports.worker = void 0;
+const worker_1 = require("./worker");
+Object.defineProperty(exports, "worker", { enumerable: true, get: function () { return worker_1._worker; } });
+const promisifyWorker_1 = require("./promisifyWorker");
+Object.defineProperty(exports, "promisifyWorker", { enumerable: true, get: function () { return promisifyWorker_1._promisifyWorker; } });

package/worker/promisifyWorker.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { _WorkerPromiseInstance as WorkerPromiseInstance } from './types';
2	+ export declare function _promisifyWorker<T extends object>(w: Worker, givenWorkerService: object): WorkerPromiseInstance<T>;

package/worker/promisifyWorker.js ADDED Viewed

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._promisifyWorker = void 0;
+function _promisifyWorker(w, givenWorkerService) {
+    const workerService = givenWorkerService;
+    const instance = {};
+    let callsKey = 0;
+    if (typeof Worker === 'undefined' || !(w instanceof Worker)) {
+        throw new Error('Worker is not provided');
+    }
+    instance.terminate = () => w.terminate();
+    for (const method of Object.keys(workerService._handlers)) {
+        const { isGenerator } = workerService._handlers[method];
+        const value = workerService[method];
+        if (isGenerator) {
+            // @ts-expect-error TODO Fix this
+            instance[method] = (...args) => {
+                const key = callsKey;
+                callsKey += 1;
+                return {
+                    async *[Symbol.asyncIterator]() {
+                        const messageQueue = [];
+                        let messageResolver = null;
+                        const onMessage = (e) => {
+                            const { method: m, key: k } = e.data;
+                            if (k !== key || m !== method) {
+                                return;
+                            }
+                            if (messageResolver) {
+                                messageResolver(e.data);
+                                messageResolver = null;
+                            }
+                            else {
+                                messageQueue.push(e.data);
+                            }
+                        };
+                        const onError = (e) => {
+                            if (messageResolver) {
+                                messageResolver({ error: e.error });
+                                messageResolver = null;
+                            }
+                            else {
+                                messageQueue.push({ error: e.error });
+                            }
+                            w.removeEventListener('message', onMessage);
+                            w.removeEventListener('error', onError);
+                            throw e.error;
+                        };
+                        w.addEventListener('message', onMessage);
+                        w.addEventListener('error', onError);
+                        w.postMessage({ key, args, method });
+                        try {
+                            while (true) {
+                                let message = null;
+                                if (messageQueue.length > 0) {
+                                    message = messageQueue.shift();
+                                }
+                                else {
+                                    message = await new Promise((resolve) => {
+                                        messageResolver = resolve;
+                                    });
+                                }
+                                const { result, error, done } = message;
+                                if (error) {
+                                    throw error;
+                                }
+                                if (done) {
+                                    break;
+                                }
+                                yield result;
+                            }
+                            w.removeEventListener('message', onMessage);
+                            w.removeEventListener('error', onError);
+                        }
+                        catch (e) {
+                            w.removeEventListener('message', onMessage);
+                            w.removeEventListener('error', onError);
+                            throw e;
+                        }
+                    },
+                };
+            };
+        }
+        else {
+            // @ts-expect-error TODO Fix this
+            instance[method] = (...args) => {
+                return new Promise((resolve, reject) => {
+                    const key = callsKey;
+                    callsKey += 1;
+                    const onError = (e) => {
+                        w.removeEventListener('message', onMessage);
+                        w.removeEventListener('error', onError);
+                        reject(e);
+                    };
+                    const onMessage = (e) => {
+                        const { result, error, key: k, method: m } = e.data;
+                        if (k !== key || m !== method) {
+                            return;
+                        }
+                        w.removeEventListener('message', onMessage);
+                        w.removeEventListener('error', onError);
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(result);
+                        }
+                    };
+                    w.addEventListener('message', onMessage);
+                    w.addEventListener('error', onError);
+                    w.postMessage({ key, args, method });
+                });
+            };
+        }
+    }
+    return instance;
+}
+exports._promisifyWorker = _promisifyWorker;

package/worker/types.d.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import type { _KnownAny as KnownAny } from '../types';
+type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
+type ToAsyncGenerator<T> = T extends AsyncGenerator<unknown, unknown, unknown> ? T : T extends Generator<infer U, unknown, unknown> ? AsyncGenerator<U, unknown, unknown> : AsyncGenerator<T, unknown, unknown>;
+type ToProperReturnType<T> = T extends Generator<unknown, unknown, unknown> | AsyncGenerator<unknown, unknown, unknown> ? ToAsyncGenerator<T> : ToPromise<T>;
+export type _WorkerPromiseInstance<T> = {
+    [K in keyof T]: T[K] extends (...args: KnownAny[]) => KnownAny ? (...args: Parameters<T[K]>) => ToProperReturnType<ReturnType<T[K]>> : never;
+} & {
+    terminate: () => void;
+};
+export interface _WorkerInput {
+    method: string;
+    args: unknown[];
+    key: number;
+}
+export interface _WorkerOutput {
+    result?: unknown;
+    error?: unknown;
+    done?: true;
+    key: number;
+    method: string;
+}
+export {};

package/worker/types.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";
2	+ Object.defineProperty(exports, "__esModule", { value: true });

package/worker/worker.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export declare function _worker(): (t: object) => void;

package/worker/worker.js ADDED Viewed

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._worker = void 0;
+function _worker() {
+    return (t) => {
+        const target = t;
+        target._handlers = {};
+        // Experimental: You can pass Worker Service instead of metadata to prommisify worker
+        for (const key of Object.getOwnPropertyNames(target)) {
+            const member = target[key];
+            if (typeof member === 'function') {
+                const prototype = Object.getPrototypeOf(member);
+                const isGenerator = prototype === Object.getPrototypeOf(function* () { }) ||
+                    prototype === Object.getPrototypeOf(async function* () { });
+                target._handlers[key] = {};
+                if (isGenerator) {
+                    target._handlers[key].isGenerator = true;
+                }
+            }
+        }
+        // eslint-disable-next-line no-undef
+        if (typeof self === 'undefined')
+            return; // no-op in non-worker environment
+        // eslint-disable-next-line no-undef
+        const w = self;
+        w.onmessage = async (evt) => {
+            const { method, args, key } = evt.data;
+            try {
+                const result = await target[method](...args);
+                if (result && typeof result === 'object' && 'next' in result && typeof result.next === 'function') {
+                    const iterable = result;
+                    for await (const result of iterable) {
+                        w.postMessage({ result, key, method });
+                    }
+                    w.postMessage({ done: true, key, method });
+                }
+                else {
+                    w.postMessage({ result, key, method });
+                }
+            }
+            catch (e) {
+                w.postMessage({ error: e, key, method });
+            }
+        };
+    };
+}
+exports._worker = _worker;