@opra/core 0.2.0 → 0.4.0

package/esm/enums/http-headers.enum.js

@@ -6,7 +6,7 @@ export var HttpHeaders;
 (function (HttpHeaders) {
     /* *** Custom Headers *** */
     HttpHeaders["X_Opra_Version"] = "X-Opra-Version";
-    HttpHeaders["X_Opra_Schema"] = "X-Opra-Schema";
+    HttpHeaders["X_Opra_DataType"] = "X-Opra-DataType";
     HttpHeaders["X_Opra_Count"] = "X-Opra-Count";
     /* *** Authentication *** */
     /**

package/esm/{implementation → helpers}/headers-map.d.ts

@@ -1,4 +1,4 @@
-import { ResponsiveMap } from '@opra/schema';
+import { ResponsiveMap } from '@opra/common';
 export declare class HeadersMap extends ResponsiveMap<string, string> {
     constructor(data?: any);
     toObject(): Record<string, string>;

package/esm/{implementation → helpers}/headers-map.js

@@ -1,4 +1,4 @@
-import { ResponsiveMap } from '@opra/schema';
+import { ResponsiveMap } from '@opra/common';
 import { HttpHeaders } from '../enums/index.js';
 export class HeadersMap extends ResponsiveMap {
     constructor(data) {

package/esm/index.d.ts

@@ -2,10 +2,11 @@ import "reflect-metadata";
 export * from './types.js';
 export * from './enums/index.js';
 export * from './interfaces/execution-context.interface.js';
-export * from './interfaces/entity-service.interface.js';
-export * from './implementation/query-context.js';
-export * from './implementation/adapter.js';
-export * from './implementation/http-adapter.js';
-export * from './implementation/express-adapter.js';
+export * from './interfaces/resource.interface.js';
+export * from './adapter/query-context.js';
+export * from './adapter/adapter.js';
+export * from './adapter/http-adapter.js';
+export * from './adapter/express-adapter.js';
 export * from './services/data-service.js';
-export * from './services/json-data-service.js';
+export * from './services/json-collection-service.js';
+export * from './services/json-singleton-service.js';

package/esm/index.js

@@ -2,10 +2,11 @@ import "reflect-metadata";
 export * from './types.js';
 export * from './enums/index.js';
 export * from './interfaces/execution-context.interface.js';
-export * from './interfaces/entity-service.interface.js';
-export * from './implementation/query-context.js';
-export * from './implementation/adapter.js';
-export * from './implementation/http-adapter.js';
-export * from './implementation/express-adapter.js';
+export * from './interfaces/resource.interface.js';
+export * from './adapter/query-context.js';
+export * from './adapter/adapter.js';
+export * from './adapter/http-adapter.js';
+export * from './adapter/express-adapter.js';
 export * from './services/data-service.js';
-export * from './services/json-data-service.js';
+export * from './services/json-collection-service.js';
+export * from './services/json-singleton-service.js';

package/esm/interfaces/resource.interface.d.ts

@@ -0,0 +1,22 @@
+import { Maybe } from 'ts-gems';
+import { ResourceInfo } from '@opra/schema';
+import { PartialOutput } from '../types.js';
+export interface IResource {
+    init?(resource: ResourceInfo): void | Promise<void>;
+}
+export interface ICollectionResource<T, TOutput = PartialOutput<T>> extends IResource {
+    create?(...args: any[]): TOutput | Promise<TOutput>;
+    count?(...args: any[]): number | Promise<number>;
+    delete?(...args: any[]): boolean | Promise<boolean>;
+    deleteMany?(...args: any[]): number | Promise<number>;
+    get?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+    search?(...args: any[]): TOutput[] | Promise<TOutput[]>;
+    update?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+    updateMany?(...args: any[]): number | Promise<number>;
+}
+export interface ISingletonResource<T, TOutput = PartialOutput<T>> extends IResource {
+    create?(...args: any[]): TOutput | Promise<TOutput>;
+    delete?(...args: any[]): boolean | Promise<boolean>;
+    get?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+    update?(...args: any[]): Maybe<TOutput> | Promise<Maybe<TOutput>>;
+}

package/esm/interfaces/resource.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/services/{json-data-service.d.ts → json-collection-service.d.ts}

@@ -1,39 +1,38 @@
 import { Maybe } from 'ts-gems';
-import { EntityResource, EntityType, OpraAnyQuery, OpraSchema } from '@opra/schema';
+import { CollectionResourceInfo, ComplexType, OpraQuery, OpraSchema } from '@opra/schema';
 import { Expression } from '@opra/url';
-import { QueryContext } from '../implementation/query-context.js';
-import { IEntityService } from '../interfaces/entity-service.interface.js';
-import { EntityInput, EntityOutput } from '../types.js';
-export interface JsonDataServiceOptions {
+import { QueryContext } from '../adapter/query-context.js';
+import { PartialInput, PartialOutput } from '../types.js';
+export interface JsonCollectionServiceOptions {
     resourceName?: string;
     defaultLimit?: number;
     data?: any[];
 }
-export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IEntityService {
-    readonly resource: EntityResource;
+export declare class JsonCollectionService<T, TOutput = PartialOutput<T>> {
+    readonly resource: CollectionResourceInfo;
     private _status;
     private _initError;
     private _dbName;
     private _initData?;
     defaultLimit: number;
-    constructor(resource: EntityResource, options?: JsonDataServiceOptions);
-    get dataType(): EntityType;
+    constructor(resource: CollectionResourceInfo, options?: JsonCollectionServiceOptions);
+    get dataType(): ComplexType;
     get primaryKey(): string;
     get resourceName(): string;
     close(): Promise<void>;
     processRequest(ctx: QueryContext): Promise<any>;
-    get(keyValue: any, options?: JsonDataService.GetOptions): Promise<Maybe<TOutput>>;
-    count(options?: JsonDataService.SearchOptions): Promise<number>;
-    search(options?: JsonDataService.SearchOptions): Promise<TOutput[]>;
-    create(data: EntityInput<T>, options?: JsonDataService.CreateOptions): Promise<TOutput>;
-    update(keyValue: any, data: EntityInput<T>, options?: JsonDataService.UpdateOptions): Promise<Maybe<TOutput>>;
-    updateMany(data: EntityInput<T>, options?: JsonDataService.UpdateManyOptions): Promise<number>;
+    get(keyValue: any, options?: JsonCollectionService.GetOptions): Promise<Maybe<TOutput>>;
+    count(options?: JsonCollectionService.SearchOptions): Promise<number>;
+    search(options?: JsonCollectionService.SearchOptions): Promise<TOutput[]>;
+    create(data: PartialInput<T>, options?: JsonCollectionService.CreateOptions): Promise<TOutput>;
+    update(keyValue: any, data: PartialInput<T>, options?: JsonCollectionService.UpdateOptions): Promise<Maybe<TOutput>>;
+    updateMany(data: PartialInput<T>, options?: JsonCollectionService.UpdateManyOptions): Promise<number>;
     delete(keyValue: any): Promise<boolean>;
-    deleteMany(options?: JsonDataService.DeleteManyOptions): Promise<number>;
+    deleteMany(options?: JsonCollectionService.DeleteManyOptions): Promise<number>;
     private _waitInitializing;
     protected _init(): Promise<void>;
-    protected _prepare(query: OpraAnyQuery): {
-        method: OpraSchema.EntityMethod;
+    protected _prepare(query: OpraQuery): {
+        method: OpraSchema.CollectionMethod;
         options: any;
         keyValue?: any;
         values?: any;
@@ -46,7 +45,7 @@ export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IE
     }): string[];
     protected _convertFilter(str: string | Expression | undefined | {}): any;
 }
-export declare namespace JsonDataService {
+export declare namespace JsonCollectionService {
     type CountOptions = {
         filter?: string | Expression | {};
     };

package/esm/services/{json-data-service.js → json-collection-service.js}

@@ -2,11 +2,12 @@ import _ from 'lodash';
 import merge from 'putil-merge';
 import { nSQL } from "@nano-sql/core";
 import { BadRequestError, MethodNotAllowedError, ResourceConflictError } from '@opra/exception';
-import { ComplexType, EntityResource } from '@opra/schema';
+import { CollectionResourceInfo, ComplexType } from '@opra/schema';
 import { $parse, ArrayExpression, BooleanLiteral, ComparisonExpression, DateLiteral, Expression, LogicalExpression, NullLiteral, NumberLiteral, ParenthesesExpression, QualifiedIdentifier, StringLiteral, TimeLiteral } from '@opra/url';
 import { pathToTree } from '../utils/path-to-tree.js';
 let dbId = 1;
-export class JsonDataService {
+const indexingTypes = ['int', 'float', 'number', 'date', 'string'];
+export class JsonCollectionService {
     resource;
     _status = '';
     _initError;
@@ -15,6 +16,8 @@ export class JsonDataService {
     defaultLimit;
     constructor(resource, options) {
         this.resource = resource;
+        if (this.resource.keyFields.length > 1)
+            throw new TypeError('JsonDataService currently doesn\'t support multiple primary keys');
         this.defaultLimit = options?.defaultLimit ?? 10;
         this._initData = options?.data;
     }
@@ -22,7 +25,7 @@ export class JsonDataService {
         return this.resource.dataType;
     }
     get primaryKey() {
-        return this.resource.dataType.primaryKey;
+        return this.resource.keyFields[0];
     }
     get resourceName() {
         return this.resource.name;
@@ -55,11 +58,16 @@ export class JsonDataService {
             include: options?.include,
         });
         nSQL().useDatabase(this._dbName);
-        const rows = await nSQL(this.resourceName)
-            .query('select', select)
-            .where([this.primaryKey, '=', keyValue])
-            .exec();
-        return unFlatten(rows[0]);
+        try {
+            const rows = await nSQL(this.resourceName)
+                .query('select', select)
+                .where([this.primaryKey, '=', keyValue])
+                .exec();
+            return unFlatten(rows[0]);
+        }
+        catch (e) {
+            throw e;
+        }
     }
     async count(options) {
         await this._init();
@@ -95,19 +103,19 @@ export class JsonDataService {
         await this._init();
         const keyValue = data[this.primaryKey];
         nSQL().useDatabase(this._dbName);
-        const rows = await nSQL(this._initData).query('select', [this.primaryKey])
+        const rows = await nSQL(this.resourceName).query('select', [this.primaryKey])
             .where([this.primaryKey, '=', keyValue])
             .exec();
         if (rows.length)
             throw new ResourceConflictError(this.resourceName, this.primaryKey);
-        await nSQL(this._initData).query('upsert', data)
+        await nSQL(this.resourceName).query('upsert', data)
             .exec();
         return await this.get(keyValue, options);
     }
     async update(keyValue, data, options) {
         await this._init();
         nSQL().useDatabase(this._dbName);
-        await nSQL(this._initData)
+        await nSQL(this.resourceName)
             .query('conform rows', (row) => {
             const out = merge({}, row, { deep: true, clone: true });
             merge(out, data, { deep: true });
@@ -115,16 +123,15 @@ export class JsonDataService {
         })
             .where([this.primaryKey, '=', keyValue])
             .exec();
-        await nSQL(this._initData).query("rebuild indexes").exec();
+        // await nSQL(this.resourceName).query("rebuild indexes").exec();
         return this.get(keyValue, options);
     }
     async updateMany(data, options) {
         await this._init();
         const filter = this._convertFilter(options?.filter);
-        await this._init();
         nSQL().useDatabase(this._dbName);
         let affected = 0;
-        await nSQL(this._initData)
+        await nSQL(this.resourceName)
             .query('conform rows', (row) => {
             const out = merge({}, row, { deep: true, clone: true });
             merge(out, data, { deep: true });
@@ -133,13 +140,13 @@ export class JsonDataService {
         })
             .where(filter)
             .exec();
-        await nSQL(this._initData).query("rebuild indexes").exec();
+        // await nSQL(this.resourceName).query("rebuild indexes").exec();
         return affected;
     }
     async delete(keyValue) {
         await this._init();
         nSQL().useDatabase(this._dbName);
-        const result = await nSQL(this._initData)
+        const result = await nSQL(this.resourceName)
             .query('delete')
             .where([this.primaryKey, '=', keyValue])
             .exec();
@@ -149,7 +156,7 @@ export class JsonDataService {
         await this._init();
         const filter = this._convertFilter(options?.filter);
         nSQL().useDatabase(this._dbName);
-        const result = await nSQL(this._initData)
+        const result = await nSQL(this.resourceName)
             .query('delete')
             .where(filter)
             .exec();
@@ -178,36 +185,45 @@ export class JsonDataService {
         this._status = 'initializing';
         this._dbName = 'JsonDataService_DB_' + (dbId++);
         try {
-            const model = {
+            const table = {
                 name: this.resourceName,
-                model: {
-                    '*:any': {}
-                },
-                indexes: {},
-                primaryKey: this.primaryKey
+                model: {},
+                indexes: {}
             };
+            for (const [k, f] of this.resource.dataType.fields.entries()) {
+                const fieldType = this.resource.document.getDataType(f.type || 'string');
+                const o = table.model[k + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
+                if (k === this.primaryKey)
+                    o.pk = true;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const indexes = table.indexes;
             // Add indexes for sort fields
-            const searchMethod = this.resource.metadata.methods.search;
-            if (searchMethod) {
-                if (searchMethod.sortFields) {
-                    searchMethod.sortFields.forEach(fieldName => {
+            const searchResolver = this.resource.metadata.search;
+            if (searchResolver) {
+                if (searchResolver.sortFields) {
+                    searchResolver.sortFields.forEach(fieldName => {
                         const f = this.dataType.getField(fieldName);
-                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
-                        model.indexes[fieldName + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
+                        const fieldType = this.resource.document.getDataType(f.type || 'string');
+                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
+                        if (indexingTypes.includes(t))
+                            indexes[fieldName + ':' + t] = {};
                     });
                 }
-                if (searchMethod.filters) {
-                    searchMethod.filters.forEach(filter => {
+                if (searchResolver.filters) {
+                    searchResolver.filters.forEach(filter => {
                         const f = this.dataType.getField(filter.field);
-                        const fieldType = this.resource.owner.getDataType(f.type || 'string');
-                        model.indexes[filter.field + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
+                        const fieldType = this.resource.document.getDataType(f.type || 'string');
+                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
+                        if (indexingTypes.includes(t))
+                            indexes[filter.field + ':' + t] = {};
                     });
                 }
             }
             await nSQL().createDatabase({
                 id: this._dbName,
                 version: 3,
-                tables: [model]
+                tables: [table]
             });
             this._status = 'initialized';
             if (this._initData) {
@@ -221,13 +237,14 @@ export class JsonDataService {
         catch (e) {
             this._initError = e;
             this._status = 'error';
+            throw e;
         }
     }
     _prepare(query) {
-        if (query.resource instanceof EntityResource) {
+        if (query.resource instanceof CollectionResourceInfo) {
             if (query.dataType !== this.dataType)
                 throw new TypeError(`Query data type (${query.dataType.name}) ` +
-                    `differs from JsonDataService data type (${this.dataType.name})`);
+                    `differs from JsonCollectionService data type (${this.dataType.name})`);
         }
         switch (query.method) {
             case 'count': {
@@ -255,7 +272,7 @@ export class JsonDataService {
                 };
             }
             case 'get': {
-                if (query.kind === 'GetInstanceQuery') {
+                if (query.kind === 'CollectionGetQuery') {
                     const options = _.omitBy({
                         pick: query.pick,
                         omit: query.omit,
@@ -269,7 +286,7 @@ export class JsonDataService {
                         args: [keyValue, options]
                     };
                 }
-                if (query.kind === 'GetFieldQuery') {
+                if (query.kind === 'FieldGetQuery') {
                     // todo
                 }
                 break;
@@ -348,7 +365,7 @@ export class JsonDataService {
     }
     _convertSelect(args) {
         const result = [];
-        const document = this.dataType.owner;
+        const document = this.dataType.document;
         const processDataType = (dt, path, pick, omit, include) => {
             let kl;
             for (const [k, f] of dt.fields) {
@@ -459,7 +476,7 @@ function dataTypeToSQLType(dataType, isArray) {
         out = 'object';
     else {
         switch (dataType.name) {
-            case 'booolean':
+            case 'boolean':
             case 'number':
             case 'string':
                 out = dataType.name;
@@ -467,10 +484,10 @@ function dataTypeToSQLType(dataType, isArray) {
             case 'integer':
                 out = 'int';
                 break;
-            case 'date':
-            case 'date-time':
-                out = 'date';
-                break;
+            // case 'date': //there is bug in nano-sql.
+            // case 'date-time':
+            //   out = 'date';
+            //   break;
             case 'time':
                 out = 'string';
                 break;

package/esm/services/json-singleton-service.d.ts

@@ -0,0 +1,39 @@
+import { DataType, OpraQuery, OpraSchema } from '@opra/schema';
+import { QueryContext } from '../adapter/query-context.js';
+import { PartialOutput } from '../types.js';
+export interface JsonSingletonServiceOptions<T> {
+    data: T;
+    resourceName?: string;
+}
+export declare class JsonSingletonService<T, TOutput = PartialOutput<T>> {
+    readonly dataType: DataType;
+    protected _data?: T;
+    constructor(dataType: DataType, options?: JsonSingletonServiceOptions<T>);
+    processRequest(ctx: QueryContext): Promise<any>;
+    get(options?: JsonSingletonService.GetOptions): TOutput | undefined;
+    protected _prepare(query: OpraQuery): {
+        method: OpraSchema.SingletonMethod;
+        options: any;
+        keyValue?: any;
+        values?: any;
+        args: any[];
+    };
+}
+export declare namespace JsonSingletonService {
+    type CreateOptions = {
+        query?: string;
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type GetOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+    type UpdateOptions = {
+        pick?: string[];
+        omit?: string[];
+        include?: string[];
+    };
+}

package/esm/services/json-singleton-service.js

@@ -0,0 +1,92 @@
+import _ from 'lodash';
+import { SingletonResourceInfo } from '@opra/schema';
+export class JsonSingletonService {
+    dataType;
+    _data;
+    constructor(dataType, options) {
+        this.dataType = dataType;
+        this._data = options?.data;
+    }
+    async processRequest(ctx) {
+        const prepared = this._prepare(ctx.query);
+        const fn = this[prepared.method];
+        if (!fn)
+            throw new TypeError(`Unimplemented method (${prepared.method})`);
+        // @ts-ignore
+        return fn.apply(this, prepared.args);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    get(options) {
+        return this._data;
+    }
+    _prepare(query) {
+        if (query.resource instanceof SingletonResourceInfo) {
+            if (query.dataType !== this.dataType)
+                throw new TypeError(`Query data type (${query.dataType.name}) ` +
+                    `differs from JsonCollectionService data type (${this.dataType.name})`);
+        }
+        switch (query.method) {
+            case 'create': {
+                const options = _.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, _.isNil);
+                const { data } = query;
+                return {
+                    method: query.method,
+                    values: data,
+                    options,
+                    args: [data, options]
+                };
+            }
+            case 'get': {
+                if (query.kind === 'CollectionGetQuery') {
+                    const options = _.omitBy({
+                        pick: query.pick,
+                        omit: query.omit,
+                        include: query.include
+                    }, _.isNil);
+                    const keyValue = query.keyValue;
+                    return {
+                        method: query.method,
+                        keyValue,
+                        options,
+                        args: [keyValue, options]
+                    };
+                }
+                if (query.kind === 'FieldGetQuery') {
+                    // todo
+                }
+                break;
+            }
+            case 'update': {
+                const options = _.omitBy({
+                    pick: query.pick,
+                    omit: query.omit,
+                    include: query.include
+                }, _.isNil);
+                const { data } = query;
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue: query.keyValue,
+                    values: data,
+                    options,
+                    args: [keyValue, data, options]
+                };
+            }
+            case 'delete': {
+                const options = {};
+                const keyValue = query.keyValue;
+                return {
+                    method: query.method,
+                    keyValue,
+                    options,
+                    args: [keyValue, options]
+                };
+            }
+        }
+        throw new Error(`Unimplemented query type "${query.method}"`);
+    }
+}

package/esm/types.d.ts

@@ -1,8 +1,2 @@
-import { Builtin, DeepPickWritable } from 'ts-gems';
-export declare type EntityInput<T> = DeepNullableIfPartial<DeepPickWritable<T>>;
-export declare type EntityOutput<T> = DeepNullableIfPartial<T>;
-export declare type DeepNullableIfPartial<T> = _DeepNullableIfPartial<T>;
-declare type _DeepNullableIfPartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullableIfPartial<U>> : T extends (infer U)[] ? DeepNullableIfPartial<U>[] : {
-    [P in keyof T]?: DeepNullableIfPartial<Exclude<T[P], undefined>> | null;
-};
-export {};
+import { PartialInput, PartialOutput } from '@opra/common';
+export { PartialInput, PartialOutput };

package/esm/utils/create-i18n.d.ts

@@ -1,3 +1,3 @@
 import { I18n } from '@opra/i18n';
-import { OpraAdapter } from '../implementation/adapter.js';
+import { OpraAdapter } from '../adapter/adapter.js';
 export declare function createI18n(options?: OpraAdapter.I18nOptions): Promise<I18n>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "postbuild": "npm run _copyi18n && npm run _copy_pkg_files",
     "_copy_pkg_files": "cp README.md package.json ../../LICENSE ../../build/core && cp ../../package.cjs.json ../../build/core/cjs/package.json",
     "_copyi18n": "cp -R i18n ../../build/core/i18n",
-    "lint": "eslint .",
+    "lint": "eslint . --max-warnings=0",
     "test": "jest",
     "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
@@ -27,24 +27,26 @@
     "clean:cover": "rimraf ../../coverage/core"
   },
   "dependencies": {
-    "@opra/exception": "^0.2.0",
-    "@opra/i18n": "^0.2.0",
-    "@opra/optionals": "^0.2.0",
-    "@opra/schema": "^0.2.0",
-    "@opra/url": "^0.2.0",
     "@nano-sql/core": "^2.3.7",
-    "express": "^4.18.1",
+    "@opra/common": "^0.4.0",
+    "@opra/exception": "^0.4.0",
+    "@opra/i18n": "^0.4.0",
+    "@opra/optionals": "^0.4.0",
+    "@opra/schema": "^0.4.0",
+    "@opra/url": "^0.4.0",
+    "axiosist": "^1.0.0",
     "body-parser": "^1.20.1",
+    "express": "^4.18.2",
     "lodash": "^4.17.21",
     "putil-isplainobject": "^1.1.4",
-    "putil-varhelpers": "^1.6.4",
     "putil-merge": "^3.9.0",
-    "strict-typed-events": "^2.2.0",
-    "ts-gems": "^2.2.0"
+    "putil-varhelpers": "^1.6.4",
+    "strict-typed-events": "^2.3.1",
+    "ts-gems": "^2.3.0"
   },
   "devDependencies": {
-    "@types/express": "^4.17.14",
-    "@faker-js/faker": "^7.5.0"
+    "@faker-js/faker": "^7.6.0",
+    "@types/express": "^4.17.14"
   },
   "type": "module",
   "types": "esm/index.d.ts",
@@ -79,4 +81,4 @@
     "http",
     "web"
   ]
-}
+}