@opra/common 0.13.0 → 0.15.0

package/esm/document/resource/resource.d.ts

@@ -0,0 +1,29 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { nodeInspectCustom } from '../utils/inspect.util.js';
+export declare namespace Resource {
+    interface InitArguments extends StrictOmit<OpraSchema.ResourceBase, 'kind'> {
+        name: string;
+        controller?: object | Type;
+    }
+    interface DecoratorOptions extends Partial<Pick<InitArguments, 'name' | 'description'>> {
+    }
+}
+export interface Resource {
+    readonly document: ApiDocument;
+    readonly kind: OpraSchema.Resource.Kind;
+    readonly name: string;
+    readonly description?: string;
+    readonly controller?: object | Type;
+    exportSchema(): OpraSchema.ResourceBase;
+    toString(): string;
+    [nodeInspectCustom](): string;
+    _construct(init: Resource.InitArguments): void;
+}
+export interface ResourceConstructor {
+    readonly prototype: Resource;
+    new (document: ApiDocument, init: Resource.InitArguments): Resource;
+    (...args: any[]): void;
+}
+export declare const Resource: ResourceConstructor;

package/esm/document/resource/resource.js

@@ -0,0 +1,35 @@
+import { omitUndefined } from '../../helpers/object-utils.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
+export const Resource = function (document, init) {
+    if (!(this instanceof Resource)) {
+        throw new TypeError(`Class constructor must be called with "new" keyword`);
+        // noinspection UnreachableCodeJS
+        return;
+    }
+    const _this = this;
+    _this.document = document;
+    _this.name = init.name;
+    _this.description = init.description;
+    _this.controller = init.controller;
+    _this._construct(init);
+};
+const proto = {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _construct(init) {
+        // Do nothing
+    },
+    exportSchema() {
+        return omitUndefined({
+            kind: this.kind,
+            description: this.description
+        });
+    },
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#anonymous'}]`;
+    },
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`;
+    }
+};
+Object.assign(Resource.prototype, proto);

package/esm/document/resource/singleton.d.ts

@@ -0,0 +1,49 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { TypeThunkAsync } from '../../types.js';
+import type { ApiDocument } from '../api-document.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import { Resource } from './resource.js';
+export declare namespace Singleton {
+    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Singleton, 'operations'> {
+        type: ComplexType;
+    }
+    export interface DecoratorOptions extends Resource.DecoratorOptions {
+    }
+    export interface Metadata extends StrictOmit<OpraSchema.Singleton, 'type'> {
+        name: string;
+        type: TypeThunkAsync | string;
+    }
+    interface Operation {
+        handlerName?: string;
+    }
+    export interface Operations {
+        create?: OpraSchema.Singleton.CreateOperation & Operation;
+        delete?: OpraSchema.Singleton.DeleteOperation & Operation;
+        get?: OpraSchema.Singleton.GetOperation & Operation;
+        update?: OpraSchema.Singleton.UpdateOperation & Operation;
+    }
+    export type CreateOperationOptions = StrictOmit<OpraSchema.Singleton.CreateOperation, 'handler'>;
+    export type DeleteOperationOptions = StrictOmit<OpraSchema.Singleton.DeleteOperation, 'handler'>;
+    export type GetOperationOptions = StrictOmit<OpraSchema.Singleton.GetOperation, 'handler'>;
+    export type UpdateOperationOptions = StrictOmit<OpraSchema.Singleton.UpdateOperation, 'handler'>;
+    export {};
+}
+export interface Singleton extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
+    readonly type: ComplexType;
+    readonly operations: Singleton.Operations;
+    readonly controller?: object | Type;
+    exportSchema(): OpraSchema.Singleton;
+    normalizeFieldNames(fields: string[]): string[] | undefined;
+    _construct(init: Singleton.InitArguments): void;
+}
+export interface SingletonConstructor {
+    prototype: Singleton;
+    new (document: ApiDocument, init: Singleton.InitArguments): Singleton;
+    (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
+    CreateOperation: (options?: Singleton.CreateOperationOptions) => PropertyDecorator;
+    GetOperation: (options?: Singleton.GetOperationOptions) => PropertyDecorator;
+    DeleteOperation: (options?: Singleton.DeleteOperationOptions) => PropertyDecorator;
+    UpdateOperation: (options?: Singleton.UpdateOperationOptions) => PropertyDecorator;
+}
+export declare const Singleton: SingletonConstructor;

package/esm/document/resource/singleton.js

@@ -0,0 +1,87 @@
+import omit from 'lodash.omit';
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { METADATA_KEY } from '../constants.js';
+import { Resource } from './resource.js';
+const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
+const NAME_PATTERN = /^(.*)(Resource|Singleton)$/;
+export const Singleton = function (...args) {
+    // ClassDecorator
+    if (!this) {
+        const [type, options] = args;
+        return function (target) {
+            const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+            metadata.kind = OpraSchema.Singleton.Kind;
+            metadata.name = name;
+            metadata.type = type;
+            // Merge with previous metadata object
+            const m = Reflect.getMetadata(METADATA_KEY, target);
+            if (m && metadata !== m)
+                Object.assign(metadata, omit(m), Object.keys(metadata));
+            // Merge options
+            if (options)
+                Object.assign(metadata, omit(options, ['kind', 'name', 'type', 'controller']));
+            Reflect.defineMetadata(METADATA_KEY, metadata, target);
+            /* Define Injectable metadata for NestJS support*/
+            Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
+        };
+    }
+    // Constructor
+    const [document, init] = args;
+    // call super()
+    Resource.apply(this, [document, init]);
+};
+const proto = {
+    _construct(init) {
+        // call super()
+        Resource.prototype._construct.call(this, init);
+        const _this = this;
+        _this.kind = OpraSchema.Singleton.Kind;
+        _this.controller = init.controller;
+        const operations = _this.operations = init.operations || {};
+        _this.type = init.type;
+        if (_this.controller) {
+            const instance = typeof _this.controller == 'function'
+                ? new _this.controller()
+                : _this.controller;
+            for (const operation of Object.values(operations)) {
+                if (!operation.handler && operation.handlerName) {
+                    const fn = instance[operation.handlerName];
+                    if (!fn)
+                        throw new TypeError(`No such operation handler (${operation.handlerName}) found`);
+                    operation.handler = fn.bind(instance);
+                }
+            }
+        }
+    },
+    exportSchema() {
+        const out = Resource.prototype.exportSchema.call(this);
+        Object.assign(out, omitUndefined({
+            type: this.type.name,
+            operations: this.operations
+        }));
+        return out;
+    },
+    normalizeFieldNames(fields) {
+        return this.type.normalizeFieldNames(fields);
+    },
+};
+Object.assign(Singleton.prototype, proto);
+Object.setPrototypeOf(Singleton.prototype, Resource.prototype);
+function createOperationDecorator(operation) {
+    return (options) => ((target, propertyKey) => {
+        const metadata = {
+            ...options,
+            handlerName: propertyKey
+        };
+        const resourceMetadata = (Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {});
+        resourceMetadata.operations = resourceMetadata.operations || {};
+        resourceMetadata.operations[operation] = metadata;
+        Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
+    });
+}
+Singleton.CreateOperation = createOperationDecorator('create');
+Singleton.GetOperation = createOperationDecorator('get');
+Singleton.DeleteOperation = createOperationDecorator('delete');
+Singleton.UpdateOperation = createOperationDecorator('update');

package/esm/exception/opra-exception.js

@@ -13,6 +13,8 @@ export class OpraException extends Error {
                 this.stack = cause.stack;
         }
         this._init(issue || cause || 'Unknown error');
+        if (issue instanceof Error)
+            this.stack = issue.stack;
         this.message = i18n.deep(this.issue.message);
     }
     get issue() {

package/esm/exception/resource-errors/resource-not-found.error.d.ts

@@ -1,4 +1,8 @@
 import { OpraException } from '../opra-exception.js';
+/**
+ * The server cannot find the requested resource.
+ * This can also mean that the endpoint is valid but the resource itself does not exist.
+ */
 export declare class ResourceNotFoundError extends OpraException {
     constructor(resource: string, keyValue?: any, cause?: Error);
 }

package/esm/exception/resource-errors/resource-not-found.error.js

@@ -1,5 +1,9 @@
 import { translate } from '../../i18n/index.js';
 import { OpraException } from '../opra-exception.js';
+/**
+ * The server cannot find the requested resource.
+ * This can also mean that the endpoint is valid but the resource itself does not exist.
+ */
 export class ResourceNotFoundError extends OpraException {
     constructor(resource, keyValue, cause) {
         super({

package/esm/filter/parse.js

@@ -23,7 +23,9 @@ export function parseFilter(text, visitor) {
         const errMsgs = [];
         for (const err of errors) {
             errMsgs.push(err.message +
-                ' at (' + 'line: ' + err.line + ' column: ' + err.charPositionInLine + ')');
+                (text.includes('\n')
+                    ? (' at ' + 'line: ' + err.line + ' column: ' + err.column)
+                    : (' at ' + ' column: ' + err.column)));
         }
         const e = new SyntaxError(errMsgs.join('\n'));
         e.errors = errors;

package/esm/helpers/function-utils.d.ts

@@ -0,0 +1,4 @@
+import { Type } from 'ts-gems';
+import { ThunkAsync } from '../types.js';
+export declare function resolveThunk(thunk: ThunkAsync<any>): Promise<any>;
+export declare function resolveClass(thunk: ThunkAsync<Type>): Promise<Type>;

package/esm/helpers/function-utils.js

@@ -0,0 +1,19 @@
+import promisify from 'putil-promisify';
+import { isConstructor } from './type-guards.js';
+export async function resolveThunk(thunk) {
+    thunk = promisify.isPromise(thunk) ? await thunk : thunk;
+    if (typeof thunk === 'function') {
+        if (isConstructor(thunk))
+            return thunk;
+        return resolveClass(thunk());
+    }
+    return thunk;
+}
+export async function resolveClass(thunk) {
+    thunk = promisify.isPromise(thunk) ? await thunk : thunk;
+    if (typeof thunk !== 'function')
+        throw new Error(`No Class type resolved`);
+    if (isConstructor(thunk))
+        return thunk;
+    return resolveClass(thunk());
+}

package/esm/helpers/get-stack-filename.d.ts

@@ -0,0 +1 @@
+export declare function getStackFileName(position?: number): string;

package/esm/helpers/get-stack-filename.js

@@ -0,0 +1,20 @@
+const PATH_PATTERN = /^(?:file:\/\/)?(.+)$/;
+export function getStackFileName(position = 1) {
+    if (position >= Error.stackTraceLimit) {
+        throw new TypeError('getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `' +
+            position + '` and Error.stackTraceLimit was: `' + Error.stackTraceLimit + '`');
+    }
+    const oldPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_, stack) => stack;
+    const stack = new Error().stack;
+    Error.prepareStackTrace = oldPrepareStackTrace;
+    if (stack !== null && typeof stack === 'object') {
+        // stack[0] holds this file
+        // stack[1] holds where this function was called
+        const s = stack[position] ?
+            stack[position].getFileName() : undefined;
+        const m = s ? PATH_PATTERN.exec(s) : undefined;
+        return m ? m[1] : '';
+    }
+    return '';
+}

package/esm/helpers/index.d.ts

@@ -1 +1,8 @@
+export * from './function-utils.js';
+export * from './get-stack-filename.js';
+export * from './is-url.js';
+export * from './mixin-utils.js';
+export * from './object-utils.js';
+export * from './path-to-object-tree.js';
 export * from './responsive-map.js';
+export * from './type-guards.js';

package/esm/helpers/index.js

@@ -1 +1,8 @@
+export * from './function-utils.js';
+export * from './get-stack-filename.js';
+export * from './is-url.js';
+export * from './mixin-utils.js';
+export * from './object-utils.js';
+export * from './path-to-object-tree.js';
 export * from './responsive-map.js';
+export * from './type-guards.js';

package/esm/helpers/is-url.d.ts

@@ -0,0 +1 @@
+export declare function isUrl(url: string): boolean;

package/esm/helpers/is-url.js

@@ -0,0 +1,4 @@
+const URL_PATTERN = /^(https?:\/\/.)[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/i;
+export function isUrl(url) {
+    return URL_PATTERN.test(url);
+}

package/esm/{schema/utils/clone-object.util.d.ts → helpers/object-utils.d.ts}

@@ -1 +1,2 @@
 export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;
+export declare function omitUndefined(obj: any): any;

package/esm/{schema/utils/clone-object.util.js → helpers/object-utils.js}

@@ -12,3 +12,14 @@ export function cloneObject(obj, jsonOnly) {
         }
     });
 }
+export function omitUndefined(obj) {
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    for (const k of Object.keys(obj)) {
+        if (obj[k] === undefined)
+            delete obj[k];
+        else if (typeof obj[k] === 'object')
+            omitUndefined(obj[k]);
+    }
+    return obj;
+}

package/esm/helpers/path-to-object-tree.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function pathToObjectTree(arr: string[], lowerCaseKeys?: boolean): ObjectTree | undefined;

package/esm/{utils/path-to-tree.js → helpers/path-to-object-tree.js}

@@ -1,20 +1,20 @@
-const dotPattern = /^([^.]+)\.(.*)$/;
-export function pathToTree(arr, lowerCaseKeys) {
-    if (!arr.length)
+const DOT_PATTERN = /^([^.]+)\.(.*)$/;
+export function pathToObjectTree(arr, lowerCaseKeys) {
+    if (!(arr && arr.length))
         return;
-    return _pathToTree(arr, {}, lowerCaseKeys);
+    return _pathToObjectTree(arr, {}, lowerCaseKeys);
 }
-function _pathToTree(arr, target, lowerCaseKeys) {
+function _pathToObjectTree(arr, target, lowerCaseKeys) {
     for (let k of arr) {
         if (lowerCaseKeys)
             k = k.toLowerCase();
-        const m = dotPattern.exec(k);
+        const m = DOT_PATTERN.exec(k);
         if (m) {
             const key = m[1];
             if (target[key] === true)
                 continue;
             const sub = target[key] = typeof target[key] === 'object' ? target[key] : {};
-            _pathToTree([m[2]], sub);
+            _pathToObjectTree([m[2]], sub);
         }
         else {
             target[k] = true;

package/esm/helpers/responsive-map.d.ts

@@ -2,7 +2,7 @@ export interface ResponsiveMapOptions {
     wellKnownKeys?: string[];
     caseSensitive?: boolean;
 }
-export type ResponsiveMapInit<K, V> = ResponsiveMap<K, V> | Map<K, V> | Record<any, V>;
+export type ResponsiveMapInit<V> = ResponsiveMap<V> | Map<string, V> | Record<any, V>;
 declare const kKeyMap: unique symbol;
 declare const kKeyOrder: unique symbol;
 declare const kWellKnownKeys: unique symbol;
@@ -10,23 +10,25 @@ declare const kOptions: unique symbol;
 /**
  * A Map implementation that supports case-insensitivity and ordered keys
  */
-export declare class ResponsiveMap<K, V> extends Map<K, V> {
+export declare class ResponsiveMap<V> extends Map<string, V> {
     private [kKeyMap];
     private [kKeyOrder];
     private [kWellKnownKeys];
     private [kOptions];
-    constructor(init?: ResponsiveMapInit<K, V>, options?: ResponsiveMapOptions);
+    constructor(init?: ResponsiveMapInit<V> | null, options?: ResponsiveMapOptions);
     clear(): void;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    keys(): IterableIterator<K>;
+    get(key: string): V | undefined;
+    has(key: string): boolean;
+    set(key: string, value: V): this;
+    setAll(source: ResponsiveMapInit<V>): this;
+    keys(): IterableIterator<string>;
     values(): IterableIterator<V>;
-    entries(): IterableIterator<[K, V]>;
-    delete(key: K): boolean;
-    sort(compareFn?: (a: K, b: K) => number): this;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    protected _getOriginalKey(key: K): K;
-    protected _getStoringKey(key: K): K;
+    entries(): IterableIterator<[string, V]>;
+    delete(key: string): boolean;
+    sort(compareFn?: (a: string, b: string) => number): this;
+    getProxy(handler?: ProxyHandler<Record<string, V>>): Record<string, V>;
+    [Symbol.iterator](): IterableIterator<[string, V]>;
+    protected _getOriginalKey(key: string): string;
+    protected _getStoringKey(key: string): string;
 }
 export {};

package/esm/helpers/responsive-map.js

@@ -19,11 +19,8 @@ export class ResponsiveMap extends Map {
         this[kOptions].caseSensitive = !!options?.caseSensitive;
         if (options?.wellKnownKeys)
             options.wellKnownKeys.forEach(k => this[kWellKnownKeys].set(k.toLowerCase(), k));
-        if (isMap(init)) {
-            init.forEach((v, k) => this.set(k, v));
-        }
-        else if (init && typeof init === 'object')
-            Object.keys(init).forEach(k => this.set(k, init[k]));
+        if (init)
+            this.setAll(init);
     }
     clear() {
         super.clear();
@@ -44,8 +41,15 @@ export class ResponsiveMap extends Map {
             this[kKeyOrder].push(key);
         return super.set(key, value);
     }
+    setAll(source) {
+        if (isMap(source))
+            source.forEach((v, k) => this.set(k, v));
+        else
+            Object.keys(source).forEach(k => this.set(k, source[k]));
+        return this;
+    }
     keys() {
-        return this[kKeyOrder].values();
+        return this[kKeyOrder][Symbol.iterator]();
     }
     values() {
         let i = -1;
@@ -94,22 +98,66 @@ export class ResponsiveMap extends Map {
         this[kKeyOrder].sort(compareFn);
         return this;
     }
+    getProxy(handler) {
+        const _this = this;
+        const finalHandler = {
+            get(target, p, receiver) {
+                if (typeof p === 'string')
+                    return _this.get(p);
+                return Reflect.get(target, p, receiver);
+            },
+            set(target, p, newValue, receiver) {
+                if (typeof p === 'string') {
+                    _this.set(p, newValue);
+                    return true;
+                }
+                return Reflect.set(target, p, newValue, receiver);
+            },
+            has(target, p) {
+                if (typeof p === 'string')
+                    return _this.has(p);
+                return Reflect.has(target, p);
+            },
+            ownKeys() {
+                return Array.from(_this.keys()).map(x => x.toLowerCase());
+            },
+            getPrototypeOf() {
+                return Object.prototype;
+            },
+            defineProperty(target, property, attributes) {
+                if (typeof property === 'string') {
+                    _this.set(property, attributes.value);
+                    return true;
+                }
+                return false;
+            },
+            deleteProperty(target, p) {
+                if (typeof p === 'string')
+                    return _this.delete(p);
+                return false;
+            },
+            getOwnPropertyDescriptor(target, key) {
+                if (typeof key === 'string') {
+                    const value = finalHandler.get(target, key);
+                    return { configurable: true, enumerable: true, writable: true, value };
+                }
+            },
+            ...handler
+        };
+        return new Proxy({}, finalHandler);
+    }
     [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
         return this.entries();
     }
     _getOriginalKey(key) {
-        if (this[kOptions].caseSensitive)
+        if (!key || this[kOptions].caseSensitive)
             return key;
-        if (typeof key === 'string')
-            return this[kKeyMap].get(key.toLowerCase()) ??
-                (this[kWellKnownKeys].get(key.toLowerCase()) ?? key);
-        return key;
+        return this[kKeyMap].get(key.toLowerCase()) ??
+            (this[kWellKnownKeys].get(key.toLowerCase()) ?? key);
     }
     _getStoringKey(key) {
         if (this[kOptions].caseSensitive)
             return key;
-        if (typeof key === 'string')
-            return key.toLowerCase();
-        return key;
+        return key.toLowerCase();
     }
 }

package/esm/{utils → helpers}/type-guards.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" />
 /// <reference lib="dom" />
 import { Readable } from 'stream';
-export declare function typeGuards(stream: any): boolean;
+import { Type } from 'ts-gems';
+export declare function isConstructor(fn: any): fn is Type;
+export declare function isStream(stream: any): boolean;
 export declare function isReadable(x: any): x is Readable;
 export declare function isReadableStream(x: any): x is ReadableStream;
 export declare function isBlob(x: any): x is Blob;

package/esm/{utils → helpers}/type-guards.js

@@ -1,16 +1,22 @@
-export function typeGuards(stream) {
+export function isConstructor(fn) {
+    return typeof fn === 'function' && fn.prototype &&
+        fn.prototype.constructor === fn &&
+        fn.prototype.constructor.name !== 'Function' &&
+        fn.prototype.constructor.name !== 'anonymous';
+}
+export function isStream(stream) {
     return stream !== null
         && typeof stream === 'object'
         && typeof stream.pipe === 'function';
 }
 export function isReadable(x) {
-    return typeGuards(x)
+    return isStream(x)
         && x.readable !== false
         && typeof x._read === 'function'
         && typeof x._readableState === 'object';
 }
 export function isReadableStream(x) {
-    return typeGuards(x)
+    return isStream(x)
         && x.readable !== false
         && typeof x.getReader === 'function'
         && typeof x.pipeThrough === 'function'

package/esm/http/codecs/boolean-codec.d.ts

@@ -0,0 +1,5 @@
+import type { HttpParams } from '../http-params.js';
+export declare class BooleanCodec implements HttpParams.Codec {
+    decode(value: string): boolean;
+    encode(value: any): string;
+}

package/esm/http/{param-codec → codecs}/boolean-codec.js

@@ -1,7 +1,6 @@
-import { HttpParamCodec } from '../http-param-codec.js';
 const trueValues = ['true', 't', 'yes', 'y', '1'];
 const falseValues = ['false', 'f', 'no', 'n', '0'];
-export class BooleanCodec extends HttpParamCodec {
+export class BooleanCodec {
     decode(value) {
         if (value === '')
             return true;

package/esm/http/{param-codec → codecs}/date-codec.d.ts

@@ -1,11 +1,11 @@
-import { HttpParamCodec } from '../http-param-codec.js';
+import type { HttpParams } from '../http-params.js';
 export interface DateCodecOptions {
     time?: boolean;
     timeZone?: boolean;
     min?: string;
     max?: string;
 }
-export declare class DateCodec extends HttpParamCodec {
+export declare class DateCodec implements HttpParams.Codec {
     time: boolean;
     timeZone: boolean;
     min?: string;

package/esm/http/{param-codec → codecs}/date-codec.js

@@ -1,10 +1,7 @@
-/* eslint-disable max-len */
-import { HttpParamCodec } from '../http-param-codec.js';
 // noinspection RegExpUnnecessaryNonCapturingGroup
 const DATE_FORMAT_PATTERN = /^(\d{4})(?:-?(0[1-9]|1[012])(?:-?([123]0|[012][1-9]|31))?)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
-export class DateCodec extends HttpParamCodec {
+export class DateCodec {
     constructor(options) {
-        super();
         this.max = options?.max ? coerceToDateString(options.max) : undefined;
         this.min = options?.min ? coerceToDateString(options.min) : undefined;
         this.time = options?.time ?? true;

package/esm/http/{param-codec → codecs}/filter-codec.d.ts

@@ -1,6 +1,6 @@
 import { Ast, Expression } from '../../filter/ast/index.js';
-import { HttpParamCodec } from '../http-param-codec.js';
-export declare class FilterCodec extends HttpParamCodec {
+import type { HttpParams } from '../http-params.js';
+export declare class FilterCodec implements HttpParams.Codec {
     decode(value: string | Expression): object;
     encode(value: Ast): string;
 }

package/esm/http/{param-codec → codecs}/filter-codec.js

@@ -1,7 +1,6 @@
 import { Expression } from '../../filter/ast/index.js';
 import { parseFilter } from '../../filter/parse.js';
-import { HttpParamCodec } from '../http-param-codec.js';
-export class FilterCodec extends HttpParamCodec {
+export class FilterCodec {
     decode(value) {
         if (value instanceof Expression)
             return value;

package/esm/http/codecs/integer-codec.d.ts

@@ -0,0 +1,11 @@
+import { NumberCodec } from './number-codec.js';
+export declare namespace IntegerCodec {
+    interface Options extends NumberCodec.Options {
+        enum?: number[];
+    }
+}
+export declare class IntegerCodec extends NumberCodec {
+    enum?: number[];
+    constructor(options?: IntegerCodec.Options);
+    decode(value: string): number;
+}