@acala-network/chopsticks-db 0.9.1-1 → 0.9.1-3

package/dist/cjs/base-sql.js

@@ -1,60 +1,109 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSqlDatabase = void 0;
-const entities_1 = require("./db/entities");
-class BaseSqlDatabase {
-    constructor() {
-        this.close = async () => {
-            const db = await this.datasource;
-            await db.destroy();
-        };
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BaseSqlDatabase", {
+    enumerable: true,
+    get: function() {
+        return BaseSqlDatabase;
+    }
+});
+const _entities = require("./db/entities");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
     }
+    return obj;
+}
+class BaseSqlDatabase {
     async saveBlock(block) {
         const db = await this.datasource;
         const { hash, number, header, extrinsics, parentHash, storageDiff } = block;
-        await db.transaction(async (transactionalEntityManager) => {
-            await transactionalEntityManager.getRepository(entities_1.BlockEntity).delete({ number });
-            await transactionalEntityManager.getRepository(entities_1.BlockEntity).upsert({
+        await db.transaction(async (transactionalEntityManager)=>{
+            await transactionalEntityManager.getRepository(_entities.BlockEntity).delete({
+                number
+            });
+            await transactionalEntityManager.getRepository(_entities.BlockEntity).upsert({
                 hash,
                 number,
                 header,
                 extrinsics,
                 parentHash,
-                storageDiff,
-            }, ['hash']);
+                storageDiff
+            }, [
+                'hash'
+            ]);
         });
     }
     async queryBlock(hash) {
         const db = await this.datasource;
-        return db.getRepository(entities_1.BlockEntity).findOne({ where: { hash } });
+        return db.getRepository(_entities.BlockEntity).findOne({
+            where: {
+                hash
+            }
+        });
     }
     async queryBlockByNumber(number) {
         const db = await this.datasource;
-        return db.getRepository(entities_1.BlockEntity).findOne({ where: { number }, order: { number: 'desc' } });
+        return db.getRepository(_entities.BlockEntity).findOne({
+            where: {
+                number
+            },
+            order: {
+                number: 'desc'
+            }
+        });
     }
     async queryHighestBlock() {
         const db = await this.datasource;
-        return db.getRepository(entities_1.BlockEntity).findOne({ where: {}, order: { number: 'desc' } });
+        return db.getRepository(_entities.BlockEntity).findOne({
+            where: {},
+            order: {
+                number: 'desc'
+            }
+        });
     }
     async deleteBlock(hash) {
         const db = await this.datasource;
-        await db.getRepository(entities_1.BlockEntity).delete({ hash });
+        await db.getRepository(_entities.BlockEntity).delete({
+            hash
+        });
     }
     async blocksCount() {
         const db = await this.datasource;
-        return db.getRepository(entities_1.BlockEntity).count();
+        return db.getRepository(_entities.BlockEntity).count();
     }
     async saveStorage(blockHash, key, value) {
         const db = await this.datasource;
-        await db.getRepository(entities_1.KeyValuePair).upsert({
+        await db.getRepository(_entities.KeyValuePair).upsert({
             blockHash,
             key,
-            value,
-        }, ['blockHash', 'key']);
+            value
+        }, [
+            'blockHash',
+            'key'
+        ]);
     }
     async queryStorage(blockHash, key) {
         const db = await this.datasource;
-        return db.getRepository(entities_1.KeyValuePair).findOne({ where: { blockHash, key } });
+        return db.getRepository(_entities.KeyValuePair).findOne({
+            where: {
+                blockHash,
+                key
+            }
+        });
+    }
+    constructor(){
+        _define_property(this, "close", async ()=>{
+            const db = await this.datasource;
+            await db.destroy();
+        });
     }
 }
-exports.BaseSqlDatabase = BaseSqlDatabase;

package/dist/cjs/browser.js

@@ -1,24 +1,37 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdbDatabase = void 0;
-const idb_1 = require("idb");
-class IdbDatabase {
-    constructor(location) {
-        this.datasource = (0, idb_1.openDB)(location, 1, {
-            upgrade(db) {
-                db.createObjectStore('keyValue');
-                const blockStore = db.createObjectStore('block', { keyPath: 'hash' });
-                blockStore.createIndex('byNumber', 'number');
-            },
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IdbDatabase", {
+    enumerable: true,
+    get: function() {
+        return IdbDatabase;
+    }
+});
+const _idb = require("idb");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
+    } else {
+        obj[key] = value;
     }
+    return obj;
+}
+class IdbDatabase {
     async close() {
         const db = await this.datasource;
         db.close();
     }
     async saveBlock(block) {
         const db = await this.datasource;
-        const tx = db.transaction(['block'], 'readwrite');
+        const tx = db.transaction([
+            'block'
+        ], 'readwrite');
         const store = tx.objectStore('block');
         store.delete(block.hash);
         store.put(block);
@@ -55,7 +68,22 @@ class IdbDatabase {
     async queryStorage(blockHash, key) {
         const db = await this.datasource;
         const value = await db.get('keyValue', `${blockHash}-${key}`);
-        return value !== undefined ? { blockHash, key, value } : null;
+        return value !== undefined ? {
+            blockHash,
+            key,
+            value
+        } : null;
+    }
+    constructor(location){
+        _define_property(this, "datasource", void 0);
+        this.datasource = (0, _idb.openDB)(location, 1, {
+            upgrade (db) {
+                db.createObjectStore('keyValue');
+                const blockStore = db.createObjectStore('block', {
+                    keyPath: 'hash'
+                });
+                blockStore.createIndex('byNumber', 'number');
+            }
+        });
     }
 }
-exports.IdbDatabase = IdbDatabase;

package/dist/cjs/db/entities.js

@@ -1,53 +1,68 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlockEntity = exports.KeyValuePair = void 0;
-const typeorm_1 = require("typeorm");
-exports.KeyValuePair = new typeorm_1.EntitySchema({
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    BlockEntity: function() {
+        return BlockEntity;
+    },
+    KeyValuePair: function() {
+        return KeyValuePair;
+    }
+});
+const _typeorm = require("typeorm");
+const KeyValuePair = new _typeorm.EntitySchema({
     name: 'KeyValuePair',
     columns: {
         blockHash: {
             primary: true,
             type: 'varchar',
-            nullable: false,
+            nullable: false
         },
         key: {
             primary: true,
             type: 'varchar',
-            nullable: false,
+            nullable: false
         },
         value: {
             type: 'text',
-            nullable: true,
-        },
-    },
+            nullable: true
+        }
+    }
 });
-exports.BlockEntity = new typeorm_1.EntitySchema({
+const BlockEntity = new _typeorm.EntitySchema({
     name: 'Block',
     columns: {
         hash: {
             primary: true,
             type: 'varchar',
-            nullable: false,
+            nullable: false
         },
         number: {
             type: 'int',
-            nullable: false,
+            nullable: false
         },
         header: {
             type: 'text',
-            nullable: false,
+            nullable: false
         },
         parentHash: {
             type: 'varchar',
-            nullable: true,
+            nullable: true
         },
         extrinsics: {
             type: 'simple-array',
-            nullable: false,
+            nullable: false
         },
         storageDiff: {
             type: 'simple-json',
-            nullable: true,
-        },
-    },
+            nullable: true
+        }
+    }
 });

package/dist/cjs/db/index.js

@@ -1,43 +1,67 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "openDb", {
+    enumerable: true,
+    get: function() {
+        return openDb;
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.openDb = void 0;
-const typeorm_1 = require("typeorm");
-const entities = __importStar(require("./entities"));
-const openDb = async (dbPath) => {
-    const source = new typeorm_1.DataSource({
+const _typeorm = require("typeorm");
+const _entities = /*#__PURE__*/ _interop_require_wildcard(require("./entities"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const openDb = async (dbPath)=>{
+    const source = new _typeorm.DataSource({
         type: 'sqlite',
         database: dbPath,
-        entities: Object.values(entities),
+        entities: Object.values(_entities),
         synchronize: true,
         logging: false,
         enableWAL: true,
         busyErrorRetry: 1000,
-        busyTimeout: 5000, // retry for 5 seconds, sqlite PRAGMA busy_timeout
+        busyTimeout: 5000
     });
     await source.initialize();
     return source;
 };
-exports.openDb = openDb;

package/dist/cjs/index.js

@@ -1,12 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteDatabase = void 0;
-const base_sql_1 = require("./base-sql");
-const db_1 = require("./db");
-class SqliteDatabase extends base_sql_1.BaseSqlDatabase {
-    constructor(location) {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SqliteDatabase", {
+    enumerable: true,
+    get: function() {
+        return SqliteDatabase;
+    }
+});
+const _basesql = require("./base-sql");
+const _db = require("./db");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class SqliteDatabase extends _basesql.BaseSqlDatabase {
+    constructor(location){
         super();
-        this.datasource = (0, db_1.openDb)(location);
+        _define_property(this, "datasource", void 0);
+        this.datasource = (0, _db.openDb)(location);
     }
 }
-exports.SqliteDatabase = SqliteDatabase;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/esm/base-sql.js

@@ -1,41 +1,61 @@
 import { BlockEntity, KeyValuePair } from './db/entities';
 export class BaseSqlDatabase {
-    constructor() {
-        this.close = async () => {
-            const db = await this.datasource;
-            await db.destroy();
-        };
-    }
+    close = async ()=>{
+        const db = await this.datasource;
+        await db.destroy();
+    };
     async saveBlock(block) {
         const db = await this.datasource;
         const { hash, number, header, extrinsics, parentHash, storageDiff } = block;
-        await db.transaction(async (transactionalEntityManager) => {
-            await transactionalEntityManager.getRepository(BlockEntity).delete({ number });
+        await db.transaction(async (transactionalEntityManager)=>{
+            await transactionalEntityManager.getRepository(BlockEntity).delete({
+                number
+            });
             await transactionalEntityManager.getRepository(BlockEntity).upsert({
                 hash,
                 number,
                 header,
                 extrinsics,
                 parentHash,
-                storageDiff,
-            }, ['hash']);
+                storageDiff
+            }, [
+                'hash'
+            ]);
         });
     }
     async queryBlock(hash) {
         const db = await this.datasource;
-        return db.getRepository(BlockEntity).findOne({ where: { hash } });
+        return db.getRepository(BlockEntity).findOne({
+            where: {
+                hash
+            }
+        });
     }
     async queryBlockByNumber(number) {
         const db = await this.datasource;
-        return db.getRepository(BlockEntity).findOne({ where: { number }, order: { number: 'desc' } });
+        return db.getRepository(BlockEntity).findOne({
+            where: {
+                number
+            },
+            order: {
+                number: 'desc'
+            }
+        });
     }
     async queryHighestBlock() {
         const db = await this.datasource;
-        return db.getRepository(BlockEntity).findOne({ where: {}, order: { number: 'desc' } });
+        return db.getRepository(BlockEntity).findOne({
+            where: {},
+            order: {
+                number: 'desc'
+            }
+        });
     }
     async deleteBlock(hash) {
         const db = await this.datasource;
-        await db.getRepository(BlockEntity).delete({ hash });
+        await db.getRepository(BlockEntity).delete({
+            hash
+        });
     }
     async blocksCount() {
         const db = await this.datasource;
@@ -46,11 +66,19 @@ export class BaseSqlDatabase {
         await db.getRepository(KeyValuePair).upsert({
             blockHash,
             key,
-            value,
-        }, ['blockHash', 'key']);
+            value
+        }, [
+            'blockHash',
+            'key'
+        ]);
     }
     async queryStorage(blockHash, key) {
         const db = await this.datasource;
-        return db.getRepository(KeyValuePair).findOne({ where: { blockHash, key } });
+        return db.getRepository(KeyValuePair).findOne({
+            where: {
+                blockHash,
+                key
+            }
+        });
     }
 }

package/dist/esm/browser.js

@@ -1,12 +1,15 @@
 import { openDB } from 'idb';
 export class IdbDatabase {
-    constructor(location) {
+    datasource;
+    constructor(location){
         this.datasource = openDB(location, 1, {
-            upgrade(db) {
+            upgrade (db) {
                 db.createObjectStore('keyValue');
-                const blockStore = db.createObjectStore('block', { keyPath: 'hash' });
+                const blockStore = db.createObjectStore('block', {
+                    keyPath: 'hash'
+                });
                 blockStore.createIndex('byNumber', 'number');
-            },
+            }
         });
     }
     async close() {
@@ -15,7 +18,9 @@ export class IdbDatabase {
     }
     async saveBlock(block) {
         const db = await this.datasource;
-        const tx = db.transaction(['block'], 'readwrite');
+        const tx = db.transaction([
+            'block'
+        ], 'readwrite');
         const store = tx.objectStore('block');
         store.delete(block.hash);
         store.put(block);
@@ -52,6 +57,10 @@ export class IdbDatabase {
     async queryStorage(blockHash, key) {
         const db = await this.datasource;
         const value = await db.get('keyValue', `${blockHash}-${key}`);
-        return value !== undefined ? { blockHash, key, value } : null;
+        return value !== undefined ? {
+            blockHash,
+            key,
+            value
+        } : null;
     }
 }

package/dist/esm/db/entities.js

@@ -5,18 +5,18 @@ export const KeyValuePair = new EntitySchema({
         blockHash: {
             primary: true,
             type: 'varchar',
-            nullable: false,
+            nullable: false
         },
         key: {
             primary: true,
             type: 'varchar',
-            nullable: false,
+            nullable: false
         },
         value: {
             type: 'text',
-            nullable: true,
-        },
-    },
+            nullable: true
+        }
+    }
 });
 export const BlockEntity = new EntitySchema({
     name: 'Block',
@@ -24,27 +24,27 @@ export const BlockEntity = new EntitySchema({
         hash: {
             primary: true,
             type: 'varchar',
-            nullable: false,
+            nullable: false
         },
         number: {
             type: 'int',
-            nullable: false,
+            nullable: false
         },
         header: {
             type: 'text',
-            nullable: false,
+            nullable: false
         },
         parentHash: {
             type: 'varchar',
-            nullable: true,
+            nullable: true
         },
         extrinsics: {
             type: 'simple-array',
-            nullable: false,
+            nullable: false
         },
         storageDiff: {
             type: 'simple-json',
-            nullable: true,
-        },
-    },
+            nullable: true
+        }
+    }
 });

package/dist/esm/db/index.js

@@ -1,6 +1,6 @@
 import { DataSource } from 'typeorm';
 import * as entities from './entities';
-export const openDb = async (dbPath) => {
+export const openDb = async (dbPath)=>{
     const source = new DataSource({
         type: 'sqlite',
         database: dbPath,
@@ -9,7 +9,7 @@ export const openDb = async (dbPath) => {
         logging: false,
         enableWAL: true,
         busyErrorRetry: 1000,
-        busyTimeout: 5000, // retry for 5 seconds, sqlite PRAGMA busy_timeout
+        busyTimeout: 5000
     });
     await source.initialize();
     return source;

package/dist/esm/index.js

@@ -1,7 +1,8 @@
 import { BaseSqlDatabase } from './base-sql';
 import { openDb } from './db';
 export class SqliteDatabase extends BaseSqlDatabase {
-    constructor(location) {
+    datasource;
+    constructor(location){
         super();
         this.datasource = openDb(location);
     }

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@acala-network/chopsticks-db",
-  "version": "0.9.1-1",
+  "version": "0.9.1-3",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
+  "type": "module",
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "yarn clean && tsc -p ./tsconfig.json && tsc -p ./tsconfig.esm.json"
+    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "swc ./src --config-file ../../.cjsswcrc -d dist/cjs && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "build:esm": "swc ./src --config-file ../../.esmswcrc -d dist/esm",
+    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --outDir dist/types"
   },
   "dependencies": {
-    "@acala-network/chopsticks-core": "0.9.1-1",
+    "@acala-network/chopsticks-core": "0.9.1-3",
     "idb": "^7.1.1",
     "sqlite3": "^5.1.6",
     "typeorm": "^0.3.17"
   },
   "devDependencies": {
+    "@swc/cli": "0.1.62",
+    "@swc/core": "^1.3.96",
     "typescript": "^5.1.6"
   },
   "files": [
@@ -37,6 +43,7 @@
       "import": "./dist/esm/index.js",
       "default": "./dist/esm/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./package.cjs.json": "./dist/cjs/package.json"
   }
 }