@opra/sqb 1.0.0-alpha.9 → 1.0.0-beta.2

package/esm/sqb-entity-service.js

@@ -1,6 +1,8 @@
 import { InternalServerError } from '@opra/common';
 import { ServiceBase } from '@opra/core';
+import { op } from '@sqb/builder';
 import { EntityMetadata } from '@sqb/connect';
+import { isNotNullish } from 'valgen';
 import { SQBAdapter } from './sqb-adapter.js';
 /**
  * @class SqbEntityService
@@ -20,9 +22,9 @@ export class SqbEntityService extends ServiceBase {
         this._outputCodecs = {};
         this._dataType_ = dataType;
         this.db = options?.db;
-        this.$resourceName = options?.resourceName;
-        this.$commonFilter = this.$commonFilter || options?.commonFilter;
-        this.$interceptor = this.$interceptor || options?.interceptor;
+        this.resourceName = options?.resourceName;
+        this.commonFilter = options?.commonFilter;
+        this.interceptor = options?.interceptor;
     }
     /**
      * Retrieves the OPRA data type
@@ -59,6 +61,17 @@ export class SqbEntityService extends ServiceBase {
         }
         return this._entityMetadata;
     }
+    for(context, overwriteProperties, overwriteContext) {
+        if (overwriteProperties?.commonFilter && this.commonFilter) {
+            overwriteProperties.commonFilter = [
+                ...(Array.isArray(this.commonFilter) ? this.commonFilter : [this.commonFilter]),
+                ...(Array.isArray(overwriteProperties?.commonFilter)
+                    ? overwriteProperties?.commonFilter
+                    : [overwriteProperties?.commonFilter]),
+            ];
+        }
+        return super.for(context, overwriteProperties, overwriteContext);
+    }
     /**
      * Retrieves the resource name.
      *
@@ -66,7 +79,7 @@ export class SqbEntityService extends ServiceBase {
      * @throws {Error} If the collection name is not defined.
      */
     getResourceName() {
-        const out = typeof this.$resourceName === 'function' ? this.$resourceName(this) : this.$resourceName || this.dataType.name;
+        const out = typeof this.resourceName === 'function' ? this.resourceName(this) : this.resourceName || this.dataType.name;
         if (out)
             return out;
         throw new Error('resourceName is not defined');
@@ -104,108 +117,125 @@ export class SqbEntityService extends ServiceBase {
     /**
      * Insert a new record into database
      *
-     * @param {PartialDTO<T>} input - The input data
-     * @param {SqbEntityService.CreateOptions} [options] - The options object
-     * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created resource
-     * @throws {InternalServerError} if an unknown error occurs while creating the resource
+     * @param command
+     * @returns - A promise that resolves to the created resource
      * @protected
      */
-    async _create(input, options) {
+    async _create(command) {
+        const { input, options } = command;
+        isNotNullish(command.input, { label: 'input' });
         const inputCodec = this.getInputCodec('create');
         const outputCodec = this.getOutputCodec('create');
         const data = inputCodec(input);
-        const out = await this._dbCreate(data, options);
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        const out = await repo.create(data, options);
         if (out)
             return outputCodec(out);
         throw new InternalServerError(`Unknown error while creating document for "${this.getResourceName()}"`);
     }
+    /**
+     * Insert a new record into database
+     *
+     * @param command
+     * @returns - A promise that resolves to the created resource
+     * @protected
+     */
+    async _createOnly(command) {
+        const { input, options } = command;
+        isNotNullish(command.input, { label: 'input' });
+        const inputCodec = this.getInputCodec('create');
+        const data = inputCodec(input);
+        const conn = await this.getConnection();
+        const repo = conn.getRepository(this.dataTypeClass);
+        return await repo.createOnly(data, options);
+    }
     /**
      * Returns the count of records based on the provided options
      *
-     * @param {SqbEntityService.CountOptions} options - The options for the count operation.
-     * @return {Promise<number>} - A promise that resolves to the count of records
+     * @param command
+     * @return - A promise that resolves to the count of records
      * @protected
      */
-    async _count(options) {
-        return this._dbCount(options);
+    async _count(command) {
+        return this._dbCount(command.options);
     }
     /**
      * Deletes a record from the collection.
      *
-     * @param {SQBAdapter.IdOrIds} id - The ID of the document to delete.
-     * @param {SqbEntityService.DeleteOptions} [options] - Optional delete options.
-     * @return {Promise<number>} - A Promise that resolves to the number of documents deleted.
+     * @param command
+     * @return - A Promise that resolves to the number of documents deleted.
      * @protected
      */
-    async _delete(id, options) {
-        return this._dbDelete(id, options);
+    async _delete(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        return this._dbDelete(command.documentId, command.options);
     }
     /**
      * Deletes multiple documents from the collection that meet the specified filter criteria.
      *
-     * @param {SqbEntityService.DeleteManyOptions} options - The options for the delete operation.
-     * @return {Promise<number>} - A promise that resolves to the number of documents deleted.
+     * @param command
+     * @return - A promise that resolves to the number of documents deleted.
      * @protected
      */
-    async _deleteMany(options) {
-        return await this._dbDeleteMany(options);
+    async _deleteMany(command) {
+        return await this._dbDeleteMany(command.options);
     }
     /**
      * Checks if a record with the given id exists.
      *
-     * @param {SQBAdapter.IdOrIds} id - The id of the object to check.
-     * @param {SqbEntityService.ExistsOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
+     * @param command
      * @protected
      */
-    async _exists(id, options) {
-        return await this._dbExists(id, options);
+    async _exists(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        return await this._dbExists(command.documentId, command.options);
     }
     /**
      * Checks if a record with the given arguments exists.
      *
-     * @param {SqbEntityService.ExistsOneOptions} [options] - The options for the query (optional).
-     * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
+     * @param command
+     * @return - A Promise that resolves to a boolean indicating whether the record exists or not.
      * @protected
      */
-    async _existsOne(options) {
-        return await this._dbExistsOne(options);
+    async _existsOne(command) {
+        return await this._dbExistsOne(command.options);
     }
     /**
      * Finds a record by ID.
      *
-     * @param {SQBAdapter.Id} id - The ID of the record.
-     * @param {SqbEntityService.FindOneOptions} [options] - The options for the find query.
-     * @return {Promise<PartialDTO<T | undefined>>} - A promise resolving to the found document, or undefined if not found.
+     * @param command
+     * @return - A promise resolving to the found document, or undefined if not found.
      * @protected
      */
-    async _findById(id, options) {
+    async _findById(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
         const decode = this.getOutputCodec('find');
-        const out = await this._dbFindById(id, options);
+        const out = await this._dbFindById(command.documentId, command.options);
         return out ? decode(out) : undefined;
     }
     /**
      * Finds a record in the collection that matches the specified options.
      *
-     * @param {SqbEntityService.FindOneOptions} [options] - The options for the query.
-     * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
+     * @param command
+     * @return - A promise that resolves with the found document or undefined if no document is found.
      * @protected
      */
-    async _findOne(options) {
+    async _findOne(command) {
         const decode = this.getOutputCodec('find');
-        const out = await this._dbFindOne(options);
+        const out = await this._dbFindOne(command.options);
         return out ? decode(out) : undefined;
     }
     /**
      * Finds multiple records in collection.
      *
-     * @param {SqbEntityService.FindManyOptions} [options] - The options for the find operation.
-     * @return A Promise that resolves to an array of partial outputs of type T.
+     * @param command
+     * @return - A Promise that resolves to an array of partial outputs of type T.
      * @protected
      */
-    async _findMany(options) {
+    async _findMany(command) {
         const decode = this.getOutputCodec('find');
-        const out = await this._dbFindMany(options);
+        const out = await this._dbFindMany(command.options);
         if (out?.length) {
             return out.map(x => decode(x));
         }
@@ -214,17 +244,17 @@ export class SqbEntityService extends ServiceBase {
     /**
      * Updates a record with the given id in the collection.
      *
-     * @param {SQBAdapter.IdOrIds} id - The id of the document to update.
-     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
-     * @param {SqbEntityService.UpdateOptions} [options] - The options for the update operation.
-     * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
-     * undefined if the document was not found.
+     * @param command
+     * @returns  A promise that resolves to the updated document or undefined if the document was not found.
      * @protected
      */
-    async _update(id, input, options) {
+    async _update(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        isNotNullish(command.input, { label: 'input' });
+        const { documentId, input, options } = command;
         const inputCodec = this.getInputCodec('update');
         const data = inputCodec(input);
-        const out = await this._dbUpdate(id, data, options);
+        const out = await this._dbUpdate(documentId, data, options);
         const outputCodec = this.getOutputCodec('update');
         if (out)
             return outputCodec(out);
@@ -232,29 +262,30 @@ export class SqbEntityService extends ServiceBase {
     /**
      * Updates a record in the collection with the specified ID and returns updated record count
      *
-     * @param {any} id - The ID of the document to update.
-     * @param {PatchDTO<T>} input - The partial input data to update the document with.
-     * @param {SqbEntityService.UpdateOptions} options - The options for updating the document.
-     * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
+     * @param command
+     * @returns - A promise that resolves to the number of documents modified.
      * @protected
      */
-    async _updateOnly(id, input, options) {
-        const inputCodec = this.getInputCodec('create');
+    async _updateOnly(command) {
+        isNotNullish(command.documentId, { label: 'documentId' });
+        isNotNullish(command.input, { label: 'input' });
+        const { documentId, input, options } = command;
+        const inputCodec = this.getInputCodec('update');
         const data = inputCodec(input);
-        return await this._dbUpdateOnly(id, data, options);
+        return await this._dbUpdateOnly(documentId, data, options);
     }
     /**
      * Updates multiple records in the collection based on the specified input and options.
      *
-     * @param {PatchDTO<T>} input - The partial input to update the documents with.
-     * @param {SqbEntityService.UpdateManyOptions} options - The options for updating the documents.
-     * @return {Promise<number>} - A promise that resolves to the number of documents matched and modified.
+     * @param command
+     * @return - A promise that resolves to the number of documents matched and modified.
      * @protected
      */
-    async _updateMany(input, options) {
+    async _updateMany(command) {
+        isNotNullish(command.input, { label: 'input' });
         const inputCodec = this.getInputCodec('update');
-        const data = inputCodec(input);
-        return await this._dbUpdateMany(data, options);
+        const data = inputCodec(command.input);
+        return await this._dbUpdateMany(data, command.options);
     }
     /**
      * Acquires a connection and performs Repository.create operation
@@ -440,19 +471,104 @@ export class SqbEntityService extends ServiceBase {
      * @returns {FilterInput | Promise<FilterInput> | undefined} The common filter or a Promise
      * that resolves to the common filter, or undefined if not available.
      */
-    _getCommonFilter(args) {
-        return typeof this.$commonFilter === 'function' ? this.$commonFilter(args, this) : this.$commonFilter;
-    }
-    async _intercept(callback, args) {
+    _getCommonFilter(command) {
+        const commonFilter = Array.isArray(this.commonFilter) ? this.commonFilter : [this.commonFilter];
+        const mapped = commonFilter.map(f => (typeof f === 'function' ? f(command, this) : f));
+        return mapped.length > 1 ? op.and(...mapped) : mapped[0];
+    }
+    async _executeCommand(command, commandFn) {
+        let proto;
+        const next = async () => {
+            proto = proto ? Object.getPrototypeOf(proto) : this;
+            while (proto) {
+                if (proto.interceptor && Object.prototype.hasOwnProperty.call(proto, 'interceptor')) {
+                    return await proto.interceptor.call(this, next, command, this);
+                }
+                proto = Object.getPrototypeOf(proto);
+                if (!(proto instanceof SqbEntityService))
+                    break;
+            }
+            /** Call before[X] hooks */
+            if (command.crud === 'create')
+                await this._beforeCreate(command);
+            else if (command.crud === 'update' && command.byId) {
+                await this._beforeUpdate(command);
+            }
+            else if (command.crud === 'update' && !command.byId) {
+                await this._beforeUpdateMany(command);
+            }
+            else if (command.crud === 'delete' && command.byId) {
+                await this._beforeDelete(command);
+            }
+            else if (command.crud === 'delete' && !command.byId) {
+                await this._beforeDeleteMany(command);
+            }
+            /** Call command function */
+            return commandFn();
+        };
         try {
-            if (this.$interceptor)
-                return this.$interceptor(callback, args, this);
-            return callback();
+            const result = await next();
+            /** Call after[X] hooks */
+            if (command.crud === 'create')
+                await this._afterCreate(command, result);
+            else if (command.crud === 'update' && command.byId) {
+                await this._afterUpdate(command, result);
+            }
+            else if (command.crud === 'update' && !command.byId) {
+                await this._afterUpdateMany(command, result);
+            }
+            else if (command.crud === 'delete' && command.byId) {
+                await this._afterDelete(command, result);
+            }
+            else if (command.crud === 'delete' && !command.byId) {
+                await this._afterDeleteMany(command, result);
+            }
+            return result;
         }
         catch (e) {
-            Error.captureStackTrace(e, this._intercept);
-            await this.$onError?.(e, this);
+            Error.captureStackTrace(e, this._executeCommand);
+            await this.onError?.(e, this);
             throw e;
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeCreate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdate(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeUpdateMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDelete(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _beforeDeleteMany(command) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterCreate(command, result) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterUpdate(command, result) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterUpdateMany(command, affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDelete(command, affected) {
+        // Do nothing
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async _afterDeleteMany(command, affected) {
+        // Do nothing
+    }
 }

package/esm/sqb-singleton-service.js

@@ -16,7 +16,7 @@ export class SqbSingletonService extends SqbEntityService {
      */
     constructor(dataType, options) {
         super(dataType, options);
-        this.id = this.id || options?.id || 1;
+        this.id = options?.id || 1;
     }
     /**
      * Asserts the existence of a resource based on the given options.
@@ -28,25 +28,17 @@ export class SqbSingletonService extends SqbEntityService {
         if (!(await this.exists(options)))
             throw new ResourceNotAvailableError(this.getResourceName());
     }
-    /**
-     * Inserts a single record into the database.
-     *
-     * @param {PartialDTO<T>} input - The input data
-     * @param {SqbSingletonService.CreateOptions} [options] - The options object
-     * @returns {Promise<PartialDTO<T>>} A promise that resolves to the created resource
-     * @throws {Error} if an unknown error occurs while creating the resource
-     */
     async create(input, options) {
-        const info = {
+        const command = {
             crud: 'create',
             method: 'create',
             byId: false,
             input,
             options,
         };
-        return this._intercept(async () => {
+        return this._executeCommand(command, async () => {
             const primaryFields = EntityMetadata.getPrimaryIndexColumns(this.entityMetadata);
-            const data = { ...input };
+            const data = { ...command.input };
             if (primaryFields.length > 1) {
                 if (typeof primaryFields !== 'object') {
                     throw new TypeError(`"${this.entityMetadata.name}" should has multiple primary key fields. So you should provide and object that contains key fields`);
@@ -57,8 +49,9 @@ export class SqbSingletonService extends SqbEntityService {
             }
             else
                 data[primaryFields[0].name] = this.id;
-            return await this._create(data, options);
-        }, info);
+            command.input = data;
+            return await this._create(command);
+        });
     }
     /**
      * Deletes the singleton record
@@ -67,17 +60,18 @@ export class SqbSingletonService extends SqbEntityService {
      * @return {Promise<number>} - A Promise that resolves to the number of records deleted
      */
     async delete(options) {
-        const info = {
+        const command = {
             crud: 'delete',
             method: 'delete',
             byId: true,
             documentId: this.id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._delete(this.id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._delete(command);
+        });
     }
     /**
      * Checks if the singleton record exists.
@@ -86,61 +80,41 @@ export class SqbSingletonService extends SqbEntityService {
      * @return {Promise<boolean>} - A Promise that resolves to a boolean indicating whether the record exists or not.
      */
     async exists(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'exists',
             byId: true,
             documentId: this.id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._exists(this.id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._exists(command);
+        });
     }
-    /**
-     * Finds the singleton record. Returns `undefined` if not found
-     *
-     * @param {SqbSingletonService.FindOneOptions} options - The options for the query.
-     * @return {Promise<PartialDTO<T> | undefined>} A promise that resolves with the found document or undefined if no document is found.
-     */
     async find(options) {
-        const info = {
+        const command = {
             crud: 'read',
             method: 'findById',
             byId: true,
             documentId: this.id,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._findById(this.id, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._findById(command);
+        });
     }
-    /**
-     * Retrieves the singleton record. Throws error if not found.
-     *
-     * @param {SqbSingletonService.FindOptions} [options] - Optional options for the `find` operation.
-     * @returns {Promise<PartialDTO<T>>} - A promise that resolves to the retrieved document,
-     *    or rejects with a ResourceNotFoundError if the document does not exist.
-     * @throws {ResourceNotAvailableError} - If the document does not exist.
-     */
     async get(options) {
         const out = await this.find(options);
         if (!out)
             throw new ResourceNotAvailableError(this.getResourceName());
         return out;
     }
-    /**
-     * Updates the singleton.
-     *
-     * @param {PatchDTO<T>} input - The partial input object containing the fields to update.
-     * @param {SqbSingletonService.UpdateOptions} [options] - The options for the update operation.
-     * @returns {Promise<PartialDTO<T> | undefined>} A promise that resolves to the updated document or
-     * undefined if the document was not found.
-     */
     async update(input, options) {
-        const info = {
+        const command = {
             crud: 'update',
             method: 'update',
             documentId: this.id,
@@ -148,10 +122,11 @@ export class SqbSingletonService extends SqbEntityService {
             input,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._update(this.id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._update(command);
+        });
     }
     /**
      * Updates the singleton and  returns updated record count
@@ -161,7 +136,7 @@ export class SqbSingletonService extends SqbEntityService {
      * @returns {Promise<number>} - A promise that resolves to the number of documents modified.
      */
     async updateOnly(input, options) {
-        const info = {
+        const command = {
             crud: 'update',
             method: 'update',
             documentId: this.id,
@@ -169,9 +144,10 @@ export class SqbSingletonService extends SqbEntityService {
             input,
             options,
         };
-        return this._intercept(async () => {
-            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(info), options?.filter]);
-            return this._updateOnly(this.id, input, { ...options, filter });
-        }, info);
+        return this._executeCommand(command, async () => {
+            const filter = SQBAdapter.parseFilter([await this._getCommonFilter(command), command.options?.filter]);
+            command.options = { ...command.options, filter };
+            return this._updateOnly(command);
+        });
     }
 }

package/package.json

@@ -1,51 +1,41 @@
 {
   "name": "@opra/sqb",
-  "version": "1.0.0-alpha.9",
+  "version": "1.0.0-beta.2",
   "description": "Opra SQB adapter package",
   "author": "Panates",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/panates/opra.git",
-    "directory": "packages/sqb"
-  },
-  "scripts": {
-    "compile": "tsc",
-    "prebuild": "npm run lint && npm run clean",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -b tsconfig-build-cjs.json",
-    "build:esm": "tsc -b tsconfig-build-esm.json",
-    "postbuild": "cp README.md package.json ../../LICENSE ../../build/sqb && cp ../../package.cjs.json ../../build/sqb/cjs/package.json",
-    "lint": "eslint . --max-warnings=0",
-    "lint:fix": "eslint . --max-warnings=0 --fix",
-    "format": "prettier . --write --log-level=warn",
-    "test": "jest --passWithNoTests",
-    "cover": "jest --passWithNoTests --collect-coverage",
-    "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
-    "clean:src": "ts-cleanup -s src --all",
-    "clean:test": "ts-cleanup -s test --all",
-    "clean:dist": "rimraf ../../build/client",
-    "clean:cover": "rimraf ../../coverage/client"
-  },
   "dependencies": {
-    "reflect-metadata": "^0.2.2"
-  },
-  "devDependencies": {
-    "@faker-js/faker": "^8.4.1",
-    "@sqb/builder": "^4.12.1",
-    "@sqb/connect": "^4.12.1",
-    "@sqb/postgres": "^4.12.1",
-    "postgresql-client": "^2.11.2",
-    "ts-gems": "^3.4.0"
+    "reflect-metadata": "^0.2.2",
+    "tslib": "^2.7.0",
+    "valgen": "^5.9.0"
   },
   "peerDependencies": {
-    "@opra/core": "^1.0.0-alpha.9",
-    "@sqb/connect": ">= 4.10.6"
+    "@opra/core": "^1.0.0-beta.2",
+    "@sqb/connect": ">= 4.18.0"
   },
   "type": "module",
-  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "main": "./cjs/index.js",
+  "module": "./esm/index.js",
   "types": "./types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/sqb"
+  },
   "engines": {
     "node": ">=16.0",
     "npm": ">=7.0.0"
@@ -63,4 +53,4 @@
     "sqb",
     "adapter"
   ]
-}
+}