@acala-network/chopsticks-db 0.8.5-0

package/lib/base-sql.d.ts

@@ -0,0 +1,15 @@
+import { BlockEntry, Database, KeyValueEntry } from '@acala-network/chopsticks-core';
+import { DataSource } from 'typeorm';
+import { HexString } from '@polkadot/util/types';
+export declare abstract class BaseSqlDatabase implements Database {
+    abstract datasource: Promise<DataSource>;
+    close: () => Promise<void>;
+    saveBlock: (block: BlockEntry) => Promise<void>;
+    queryBlock: (hash: HexString) => Promise<BlockEntry | null>;
+    queryBlockByNumber: (number: number) => Promise<BlockEntry | null>;
+    queryHighestBlock: () => Promise<BlockEntry | null>;
+    deleteBlock: (hash: HexString) => Promise<void>;
+    blocksCount: () => Promise<number>;
+    saveStorage: (blockHash: HexString, key: HexString, value: HexString | null) => Promise<void>;
+    queryStorage: (blockHash: HexString, key: HexString) => Promise<KeyValueEntry | null>;
+}

package/lib/base-sql.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSqlDatabase = void 0;
+const entities_1 = require("./db/entities");
+class BaseSqlDatabase {
+    constructor() {
+        this.close = () => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            yield db.destroy();
+        });
+        this.saveBlock = (block) => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            const { hash, number, header, extrinsics, parentHash, storageDiff } = block;
+            yield db.transaction((transactionalEntityManager) => __awaiter(this, void 0, void 0, function* () {
+                yield transactionalEntityManager.getRepository(entities_1.BlockEntity).delete({ number });
+                yield transactionalEntityManager.getRepository(entities_1.BlockEntity).upsert({
+                    hash,
+                    number,
+                    header,
+                    extrinsics,
+                    parentHash,
+                    storageDiff,
+                }, ['hash']);
+            }));
+        });
+        this.queryBlock = (hash) => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            return db.getRepository(entities_1.BlockEntity).findOne({ where: { hash } });
+        });
+        this.queryBlockByNumber = (number) => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            return db.getRepository(entities_1.BlockEntity).findOne({ where: { number }, order: { number: 'desc' } });
+        });
+        this.queryHighestBlock = () => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            return db.getRepository(entities_1.BlockEntity).findOne({ where: {}, order: { number: 'desc' } });
+        });
+        this.deleteBlock = (hash) => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            yield db.getRepository(entities_1.BlockEntity).delete({ hash });
+        });
+        this.blocksCount = () => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            return db.getRepository(entities_1.BlockEntity).count();
+        });
+        this.saveStorage = (blockHash, key, value) => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            yield db.getRepository(entities_1.KeyValuePair).upsert({
+                blockHash,
+                key,
+                value,
+            }, ['blockHash', 'key']);
+        });
+        this.queryStorage = (blockHash, key) => __awaiter(this, void 0, void 0, function* () {
+            const db = yield this.datasource;
+            return db.getRepository(entities_1.KeyValuePair).findOne({ where: { blockHash, key } });
+        });
+    }
+}
+exports.BaseSqlDatabase = BaseSqlDatabase;

package/lib/browser.d.ts

@@ -0,0 +1,6 @@
+import { DataSource } from 'typeorm';
+import { BaseSqlDatabase } from './base-sql';
+export declare class SqljsDatabase extends BaseSqlDatabase {
+    datasource: Promise<DataSource>;
+    constructor(location: string);
+}

package/lib/browser.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqljsDatabase = void 0;
+const base_sql_1 = require("./base-sql");
+const browser_1 = require("./db/browser");
+class SqljsDatabase extends base_sql_1.BaseSqlDatabase {
+    constructor(location) {
+        super();
+        this.datasource = (0, browser_1.openDb)(location);
+    }
+}
+exports.SqljsDatabase = SqljsDatabase;

package/lib/db/browser.d.ts

@@ -0,0 +1,2 @@
+import { DataSource } from 'typeorm';
+export declare const openDb: (location: string) => Promise<DataSource>;

package/lib/db/browser.js

@@ -0,0 +1,64 @@
+"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(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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDb = void 0;
+const typeorm_1 = require("typeorm");
+const localforage_1 = require("localforage");
+const sql_js_1 = __importDefault(require("sql.js"));
+const entities = __importStar(require("./entities"));
+const sql_wasm_1 = require("./sql-wasm");
+const openDb = (location) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!globalThis.localforage) {
+        globalThis.localforage = (0, localforage_1.createInstance)({ name: 'chopsticks' });
+    }
+    const source = new typeorm_1.DataSource({
+        type: 'sqljs',
+        location,
+        entities: Object.values(entities),
+        synchronize: true,
+        autoSave: true,
+        logging: false,
+        useLocalForage: true,
+        driver: sql_js_1.default,
+        sqlJsConfig: {
+            wasmBinary: sql_wasm_1.SQL_WASM_BYTES,
+        },
+    });
+    yield source.initialize();
+    return source;
+});
+exports.openDb = openDb;

package/lib/db/entities.d.ts

@@ -0,0 +1,4 @@
+import { BlockEntry, KeyValueEntry } from '@acala-network/chopsticks-core/src/database';
+import { EntitySchema } from 'typeorm';
+export declare const KeyValuePair: EntitySchema<KeyValueEntry>;
+export declare const BlockEntity: EntitySchema<BlockEntry>;

package/lib/db/entities.js

@@ -0,0 +1,53 @@
+"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({
+    name: 'KeyValuePair',
+    columns: {
+        blockHash: {
+            primary: true,
+            type: 'varchar',
+            nullable: false,
+        },
+        key: {
+            primary: true,
+            type: 'varchar',
+            nullable: false,
+        },
+        value: {
+            type: 'text',
+            nullable: true,
+        },
+    },
+});
+exports.BlockEntity = new typeorm_1.EntitySchema({
+    name: 'Block',
+    columns: {
+        hash: {
+            primary: true,
+            type: 'varchar',
+            nullable: false,
+        },
+        number: {
+            type: 'int',
+            nullable: false,
+        },
+        header: {
+            type: 'text',
+            nullable: false,
+        },
+        parentHash: {
+            type: 'varchar',
+            nullable: true,
+        },
+        extrinsics: {
+            type: 'simple-array',
+            nullable: false,
+        },
+        storageDiff: {
+            type: 'simple-json',
+            nullable: true,
+        },
+    },
+});

package/lib/db/index.d.ts

@@ -0,0 +1,2 @@
+import { DataSource } from 'typeorm';
+export declare const openDb: (dbPath: string) => Promise<DataSource>;

package/lib/db/index.js

@@ -0,0 +1,49 @@
+"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(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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDb = void 0;
+const typeorm_1 = require("typeorm");
+const entities = __importStar(require("./entities"));
+const openDb = (dbPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const source = new typeorm_1.DataSource({
+        type: 'sqlite',
+        database: dbPath,
+        entities: Object.values(entities),
+        synchronize: true,
+        logging: false,
+    });
+    yield source.initialize();
+    return source;
+});
+exports.openDb = openDb;

package/lib/db/sql-wasm.d.ts

@@ -0,0 +1 @@
+export declare const SQL_WASM_BYTES: Uint8Array;