From d8a85b16e376cd2ce3d2d566dddae4e00dc08667 Mon Sep 17 00:00:00 2001 From: Tadeuchi Date: Wed, 8 Nov 2023 14:15:21 +0100 Subject: [PATCH] fix: pretty, pretty --- .prettierignore | 3 + .prettierrc | 6 + package-lock.json | 17 +- src/PgContractCache.ts | 74 +++---- src/PgContractCacheOptions.ts | 2 +- src/PgSortKeyCache.ts | 79 +++----- src/PgSortKeyCacheOptions.ts | 2 +- src/__tests__/pg-cache-prune.test.ts | 54 ++--- src/__tests__/pg-cache.test.ts | 188 ++++++++---------- .../pg-sort-key-cache-commit-rollback.test.ts | 134 ++++++------- src/__tests__/utils.ts | 23 +-- src/index.ts | 8 +- 12 files changed, 241 insertions(+), 349 deletions(-) create mode 100644 .prettierignore create mode 100644 .prettierrc diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000..5f969dd --- /dev/null +++ b/.prettierignore @@ -0,0 +1,3 @@ +node_modules +lib +src/__tests__/integration/data diff --git a/.prettierrc b/.prettierrc new file mode 100644 index 0000000..0706fd1 --- /dev/null +++ b/.prettierrc @@ -0,0 +1,6 @@ +{ + "semi": true, + "trailingComma": "none", + "singleQuote": true, + "printWidth": 120 +} diff --git a/package-lock.json b/package-lock.json index 45ce14f..865a006 100644 --- a/package-lock.json +++ b/package-lock.json @@ -3633,10 +3633,13 @@ } }, "node_modules/function-bind": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", - "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", - "dev": true + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } }, "node_modules/functional-red-black-tree": { "version": "1.0.1", @@ -7323,9 +7326,9 @@ } }, "node_modules/warp-contracts": { - "version": "1.4.19", - "resolved": "https://registry.npmjs.org/warp-contracts/-/warp-contracts-1.4.19.tgz", - "integrity": "sha512-C/7R7oNcKI5p/Veskpmgi3nIK+gxJ6FLiPw7NmFMjnS3BhHuVl1BE9/AiS10uruI2zZRzkmSXlXtv5aFTGLKyg==", + "version": "1.4.22", + "resolved": "https://registry.npmjs.org/warp-contracts/-/warp-contracts-1.4.22.tgz", + "integrity": "sha512-MVbPetx1NedMnopFvNcSPo6/tCpnxmd7666VV9Td9G+8hCVXyZkDvP4xFs3bjcSQ6bO2va71dmM99O0XVL8wKA==", "peer": true, "dependencies": { "archiver": "^5.3.0", diff --git a/src/PgContractCache.ts b/src/PgContractCache.ts index f6e5ccc..0c157c1 100644 --- a/src/PgContractCache.ts +++ b/src/PgContractCache.ts @@ -4,14 +4,12 @@ import { EvalStateResult, LoggerFactory, PruneStats, - SortKeyCacheResult, -} from "warp-contracts"; -import { Pool, PoolClient } from "pg"; -import { PgContractCacheOptions } from "./PgContractCacheOptions"; - -export class PgContractCache - implements BasicSortKeyCache> -{ + SortKeyCacheResult +} from 'warp-contracts'; +import { Pool, PoolClient } from 'pg'; +import { PgContractCacheOptions } from './PgContractCacheOptions'; + +export class PgContractCache implements BasicSortKeyCache> { private readonly logger = LoggerFactory.INST.create(PgContractCache.name); private readonly pool: Pool; @@ -21,7 +19,7 @@ export class PgContractCache if (!pgCacheOptions) { this.pgCacheOptions = { minEntriesPerContract: 10, - maxEntriesPerContract: 100, + maxEntriesPerContract: 100 }; } this.pool = new Pool(pgCacheOptions); @@ -67,7 +65,7 @@ export class PgContractCache } async begin(): Promise { - await this.client.query("BEGIN;"); + await this.client.query('BEGIN;'); } async close(): Promise { @@ -80,23 +78,18 @@ export class PgContractCache } async commit(): Promise { - await this.client.query("COMMIT;"); + await this.client.query('COMMIT;'); } async delete(key: string): Promise { - await this.connection().query( - "DELETE FROM warp.sort_key_cache WHERE key = $1;", - [key] - ); + await this.connection().query('DELETE FROM warp.sort_key_cache WHERE key = $1;', [key]); } dump(): Promise { return Promise.resolve(undefined); } - async get( - cacheKey: CacheKey - ): Promise> | null> { + async get(cacheKey: CacheKey): Promise> | null> { const result = await this.connection().query( `SELECT value FROM warp.sort_key_cache @@ -114,11 +107,9 @@ export class PgContractCache return null; } - async getLast( - key: string - ): Promise> | null> { + async getLast(key: string): Promise> | null> { const result = await this.connection().query( - "SELECT sort_key, value FROM warp.sort_key_cache WHERE key = $1 ORDER BY sort_key DESC LIMIT 1", + 'SELECT sort_key, value FROM warp.sort_key_cache WHERE key = $1 ORDER BY sort_key DESC LIMIT 1', [key] ); @@ -132,18 +123,13 @@ export class PgContractCache } async getLastSortKey(): Promise { - const result = await this.connection().query( - "SELECT max(sort_key) as sort_key FROM warp.sort_key_cache" - ); - return result.rows[0].sort_key == "" ? null : result.rows[0].sortKey; + const result = await this.connection().query('SELECT max(sort_key) as sort_key FROM warp.sort_key_cache'); + return result.rows[0].sort_key == '' ? null : result.rows[0].sortKey; } - async getLessOrEqual( - key: string, - sortKey: string - ): Promise> | null> { + async getLessOrEqual(key: string, sortKey: string): Promise> | null> { const result = await this.connection().query( - "SELECT sort_key, value FROM warp.sort_key_cache WHERE key = $1 AND sort_key <= $2 ORDER BY sort_key DESC LIMIT 1", + 'SELECT sort_key, value FROM warp.sort_key_cache WHERE key = $1 AND sort_key <= $2 ORDER BY sort_key DESC LIMIT 1', [key, sortKey] ); @@ -158,13 +144,9 @@ export class PgContractCache async open(): Promise { const conf = this.pgCacheOptions; - this.logger.info( - `Connecting pg... ${conf.user}@${conf.host}:${conf.port}/${conf.database}` - ); + this.logger.info(`Connecting pg... ${conf.user}@${conf.host}:${conf.port}/${conf.database}`); this.client = await this.pool.connect(); - await this.client.query( - "CREATE schema if not exists warp; SET search_path TO 'warp';" - ); + await this.client.query("CREATE schema if not exists warp; SET search_path TO 'warp';"); await this.sortKeyTable(); await this.validityTable(); this.logger.info(`Connected`); @@ -222,7 +204,7 @@ export class PgContractCache entriesBefore: allItems, entriesAfter: allItems - deleted, sizeBefore: -1, - sizeAfter: -1, + sizeAfter: -1 }; } @@ -247,13 +229,7 @@ export class PgContractCache SET valid = EXCLUDED.valid, sort_key = EXCLUDED.sort_key, error_message = EXCLUDED.error_message`, - [ - stateCacheKey.key, - stateCacheKey.sortKey, - tx, - value.validity[tx], - value.errorMessages[tx], - ] + [stateCacheKey.key, stateCacheKey.sortKey, tx, value.validity[tx], value.errorMessages[tx]] ); } } @@ -288,11 +264,7 @@ export class PgContractCache /** * Executed in a separate pool client, so that in can be used by a separate worker. */ - async setSignature( - cacheKey: CacheKey, - hash: string, - signature: string - ): Promise { + async setSignature(cacheKey: CacheKey, hash: string, signature: string): Promise { this.logger.debug(`Attempting to set signature`, cacheKey, signature); const result = await this.pool.query( ` @@ -311,7 +283,7 @@ export class PgContractCache } async rollback(): Promise { - await this.client.query("ROLLBACK;"); + await this.client.query('ROLLBACK;'); } storage(): S { diff --git a/src/PgContractCacheOptions.ts b/src/PgContractCacheOptions.ts index ff5d65c..a64c9f0 100644 --- a/src/PgContractCacheOptions.ts +++ b/src/PgContractCacheOptions.ts @@ -1,4 +1,4 @@ -import { ClientConfig } from "pg"; +import { ClientConfig } from 'pg'; export interface PgContractCacheOptions extends ClientConfig { minEntriesPerContract: number; diff --git a/src/PgSortKeyCache.ts b/src/PgSortKeyCache.ts index 5d21fa7..b9fd450 100644 --- a/src/PgSortKeyCache.ts +++ b/src/PgSortKeyCache.ts @@ -1,14 +1,7 @@ -import { - BatchDBOp, - CacheKey, - LoggerFactory, - PruneStats, - SortKeyCache, - SortKeyCacheResult, -} from "warp-contracts"; -import { Pool, PoolClient } from "pg"; -import { SortKeyCacheRangeOptions } from "warp-contracts/lib/types/cache/SortKeyCacheRangeOptions"; -import { PgSortKeyCacheOptions } from "./PgSortKeyCacheOptions"; +import { BatchDBOp, CacheKey, LoggerFactory, PruneStats, SortKeyCache, SortKeyCacheResult } from 'warp-contracts'; +import { Pool, PoolClient } from 'pg'; +import { SortKeyCacheRangeOptions } from 'warp-contracts/lib/types/cache/SortKeyCacheRangeOptions'; +import { PgSortKeyCacheOptions } from './PgSortKeyCacheOptions'; export class PgSortKeyCache implements SortKeyCache { private readonly logger = LoggerFactory.INST.create(PgSortKeyCache.name); @@ -19,17 +12,15 @@ export class PgSortKeyCache implements SortKeyCache { constructor(private readonly pgCacheOptions: PgSortKeyCacheOptions) { if (!pgCacheOptions.tableName) { - throw new Error("Table name cannot be empty"); + throw new Error('Table name cannot be empty'); } this.tableName = pgCacheOptions.tableName; } private async createTableIfNotExists() { - await this.connection().query( - "CREATE schema if not exists warp; SET search_path TO 'warp';" - ); + await this.connection().query("CREATE schema if not exists warp; SET search_path TO 'warp';"); this.logger.info(`Attempting to create table ${this.tableName}`); - const query = ` + const query = ` CREATE TABLE IF NOT EXISTS "${this.tableName}" ( id bigserial, @@ -48,7 +39,7 @@ export class PgSortKeyCache implements SortKeyCache { if (this.client == null) { this.client = await this.pool.connect(); } - await this.client.query("BEGIN;"); + await this.client.query('BEGIN;'); } async close(): Promise { @@ -68,14 +59,11 @@ export class PgSortKeyCache implements SortKeyCache { this.logger.error(`Called commit when no connection established.`); return; } - await this.client.query("COMMIT;"); + await this.client.query('COMMIT;'); } async delete(key: string): Promise { - await this.connection().query( - `DELETE FROM warp."${this.tableName}" WHERE key = $1;`, - [key] - ); + await this.connection().query(`DELETE FROM warp."${this.tableName}" WHERE key = $1;`, [key]); } dump(): Promise { @@ -104,35 +92,24 @@ export class PgSortKeyCache implements SortKeyCache { ); if (result && result.rows && result.rows.length > 0) { - return new SortKeyCacheResult( - result.rows[0].sort_key, - result.rows[0].value - ); + return new SortKeyCacheResult(result.rows[0].sort_key, result.rows[0].value); } return null; } async getLastSortKey(): Promise { - const result = await this.connection().query( - `SELECT max(sort_key) as sort_key FROM warp."${this.tableName}";` - ); - return result.rows[0].sort_key == "" ? null : result.rows[0].sortKey; + const result = await this.connection().query(`SELECT max(sort_key) as sort_key FROM warp."${this.tableName}";`); + return result.rows[0].sort_key == '' ? null : result.rows[0].sortKey; } - async getLessOrEqual( - key: string, - sortKey: string - ): Promise | null> { + async getLessOrEqual(key: string, sortKey: string): Promise | null> { const result = await this.connection().query( `SELECT sort_key, value FROM warp."${this.tableName}" WHERE key = $1 AND sort_key <= $2 ORDER BY sort_key DESC LIMIT 1;`, [key, sortKey] ); if (result && result.rows.length > 0) { - return new SortKeyCacheResult( - result.rows[0].sort_key, - result.rows[0].value - ); + return new SortKeyCacheResult(result.rows[0].sort_key, result.rows[0].value); } return null; } @@ -144,7 +121,7 @@ export class PgSortKeyCache implements SortKeyCache { }); this.logger.info(`Connecting pg... ${conf.user}@${conf.host}:${conf.port}/${conf.database}`); - await this.pool.query( "CREATE schema if not exists warp; SET search_path TO 'warp';"); + await this.pool.query("CREATE schema if not exists warp; SET search_path TO 'warp';"); await this.createTableIfNotExists(); this.logger.info(`Setup finished`); } @@ -201,7 +178,7 @@ export class PgSortKeyCache implements SortKeyCache { entriesBefore: allItems, entriesAfter: allItems - deleted, sizeBefore: -1, - sizeAfter: -1, + sizeAfter: -1 }; } @@ -251,7 +228,7 @@ export class PgSortKeyCache implements SortKeyCache { this.logger.error(`Rollback called, but no connection established`); return; } - await this.client.query("ROLLBACK;"); + await this.client.query('ROLLBACK;'); } storage(): S { @@ -273,9 +250,9 @@ export class PgSortKeyCache implements SortKeyCache { try { await this.begin(); for (const op of opStack) { - if (op.type === "put") { + if (op.type === 'put') { await this.put(op.key, op.value); - } else if (op.type === "del") { + } else if (op.type === 'del') { await this.delete(op.key); } } @@ -300,11 +277,8 @@ export class PgSortKeyCache implements SortKeyCache { return Promise.resolve(undefined); } - async keys( - sortKey: string, - options?: SortKeyCacheRangeOptions - ): Promise { - const order = options?.reverse ? "DESC" : "ASC"; + async keys(sortKey: string, options?: SortKeyCacheRangeOptions): Promise { + const order = options?.reverse ? 'DESC' : 'ASC'; const result = await this.connection().query({ text: `WITH latest_values AS (SELECT DISTINCT ON (key) key, sort_key, value FROM warp."${this.tableName}" @@ -318,16 +292,13 @@ export class PgSortKeyCache implements SortKeyCache { from latest_values order by key ${order};`, values: [sortKey, options?.gte, options?.lt, options?.limit], - rowMode: "array", + rowMode: 'array' }); return result.rows.flat(); } - async kvMap( - sortKey: string, - options?: SortKeyCacheRangeOptions - ): Promise> { - const order = options?.reverse ? "DESC" : "ASC"; + async kvMap(sortKey: string, options?: SortKeyCacheRangeOptions): Promise> { + const order = options?.reverse ? 'DESC' : 'ASC'; const result = await this.connection().query( ` WITH latest_values AS (SELECT DISTINCT ON (key) key, sort_key, value diff --git a/src/PgSortKeyCacheOptions.ts b/src/PgSortKeyCacheOptions.ts index 3ae0c64..8ff7616 100644 --- a/src/PgSortKeyCacheOptions.ts +++ b/src/PgSortKeyCacheOptions.ts @@ -1,4 +1,4 @@ -import { ClientConfig } from "pg"; +import { ClientConfig } from 'pg'; export interface PgSortKeyCacheOptions extends ClientConfig { tableName: string; diff --git a/src/__tests__/pg-cache-prune.test.ts b/src/__tests__/pg-cache-prune.test.ts index aac2ace..91b95c3 100644 --- a/src/__tests__/pg-cache-prune.test.ts +++ b/src/__tests__/pg-cache-prune.test.ts @@ -1,8 +1,8 @@ -import { contractCache, getContractId, getSortKey } from "./utils"; -import { CacheKey } from "warp-contracts"; +import { contractCache, getContractId, getSortKey } from './utils'; +import { CacheKey } from 'warp-contracts'; -describe("Postgres cache prune", () => { - it("handle improper args", async () => { +describe('Postgres cache prune', () => { + it('handle improper args', async () => { const contracts = 10; const entriesPerContract = 1; const sut = await contractCache(contracts, entriesPerContract); @@ -14,7 +14,7 @@ describe("Postgres cache prune", () => { await sut.close(); }); - it("no deletion should be performed", async () => { + it('no deletion should be performed', async () => { const contracts = 10; const entriesPerContract = 1; const sut = await contractCache(contracts, entriesPerContract); @@ -30,31 +30,31 @@ describe("Postgres cache prune", () => { await sut.close(); }); - it("should remove all unneeded entries, one contract", async () => { + it('should remove all unneeded entries, one contract', async () => { const contracts = 1; const entriesPerContract = 10; const sut = await contractCache(contracts, entriesPerContract); expect(await sut.prune(1)).toMatchObject({ entriesBefore: contracts * entriesPerContract, - entriesAfter: contracts * 1, + entriesAfter: contracts * 1 }); await sut.drop(); await sut.close(); }); - it("should remove all unneeded entries, in many contracts", async () => { + it('should remove all unneeded entries, in many contracts', async () => { const contracts = 200; const entriesPerContract = 10; const sut = await contractCache(contracts, entriesPerContract); expect(await sut.prune(2)).toMatchObject({ entriesBefore: contracts * entriesPerContract, - entriesAfter: contracts * 2, + entriesAfter: contracts * 2 }); await sut.drop(); await sut.close(); }); - it("should remove oldest entries, in many contracts", async () => { + it('should remove oldest entries, in many contracts', async () => { const contracts = 100; const entriesPerContract = 20; const toLeave = 3; @@ -64,33 +64,19 @@ describe("Postgres cache prune", () => { for (let i = 0; i < contracts; i++) { // Check newest elements are present for (let j = 0; j < toLeave; j++) { - expect( - await sut.get( - new CacheKey( - getContractId(i), - getSortKey(entriesPerContract - j - 1) - ) - ) - ).toBeTruthy(); + expect(await sut.get(new CacheKey(getContractId(i), getSortKey(entriesPerContract - j - 1)))).toBeTruthy(); } // Check old elements are removed for (let j = toLeave; j < entriesPerContract; j++) { - expect( - await sut.get( - new CacheKey( - getContractId(i), - getSortKey(entriesPerContract - j - 1) - ) - ) - ).toBeFalsy(); + expect(await sut.get(new CacheKey(getContractId(i), getSortKey(entriesPerContract - j - 1)))).toBeFalsy(); } } await sut.drop(); await sut.close(); }); - it("deletes first contract from cache", async () => { + it('deletes first contract from cache', async () => { const contracts = 7; const entriesPerContract = 12; const sut = await contractCache(contracts, entriesPerContract); @@ -99,24 +85,20 @@ describe("Postgres cache prune", () => { // Removed elements for (let j = 0; j < entriesPerContract; j++) { - expect( - await sut.get(new CacheKey(getContractId(0), getSortKey(j))) - ).toBeFalsy(); + expect(await sut.get(new CacheKey(getContractId(0), getSortKey(j)))).toBeFalsy(); } // Remaining elements for (let i = 1; i < contracts; i++) { for (let j = 0; j < entriesPerContract; j++) { - expect( - await sut.get(new CacheKey(getContractId(i), getSortKey(j))) - ).toBeTruthy(); + expect(await sut.get(new CacheKey(getContractId(i), getSortKey(j)))).toBeTruthy(); } } await sut.drop(); await sut.close(); }); - it("deletes contract from the middle of the cache", async () => { + it('deletes contract from the middle of the cache', async () => { const contracts = 7; const entriesPerContract = 12; const removedContractIdx = 3; @@ -127,9 +109,7 @@ describe("Postgres cache prune", () => { // Remaining elements for (let i = 0; i < contracts; i++) { for (let j = 0; j < entriesPerContract; j++) { - const data = await sut.get( - new CacheKey(getContractId(i), getSortKey(j)) - ); + const data = await sut.get(new CacheKey(getContractId(i), getSortKey(j))); if (i === removedContractIdx) { expect(data).toBeFalsy(); } else { diff --git a/src/__tests__/pg-cache.test.ts b/src/__tests__/pg-cache.test.ts index 03fa4be..b83bdc8 100644 --- a/src/__tests__/pg-cache.test.ts +++ b/src/__tests__/pg-cache.test.ts @@ -1,190 +1,176 @@ -import { contractCache, getContractId, getSortKey, evalState } from "./utils"; -import { CacheKey } from "warp-contracts"; +import { contractCache, getContractId, getSortKey, evalState } from './utils'; +import { CacheKey } from 'warp-contracts'; -describe("Postgres cache", () => { - it("should return proper data", async () => { +describe('Postgres cache', () => { + it('should return proper data', async () => { const sut = await contractCache(0, 100); await sut.put( { - key: "contract0", - sortKey: - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", + key: 'contract0', + sortKey: '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' }, - evalState({ result: "contract0:sortKey0" }) + evalState({ result: 'contract0:sortKey0' }) ); await sut.put( { - key: "contract1", - sortKey: - "000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", + key: 'contract1', + sortKey: '000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' }, - evalState({ result: "contract1:sortKey1" }) + evalState({ result: 'contract1:sortKey1' }) ); await sut.put( { - key: "contract1", - sortKey: - "000000860514,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", + key: 'contract1', + sortKey: '000000860514,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' }, - evalState({ result: "contract1:sortKey2" }) + evalState({ result: 'contract1:sortKey2' }) ); await sut.put( { - key: "contract1", - sortKey: - "000000860515,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", + key: 'contract1', + sortKey: '000000860515,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' }, - evalState({ result: "contract1:sortKey3" }) + evalState({ result: 'contract1:sortKey3' }) ); await sut.put( { - key: "contract2", - sortKey: - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", + key: 'contract2', + sortKey: '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' }, - evalState({ result: "contract2:sortKey1" }) + evalState({ result: 'contract2:sortKey1' }) ); await sut.setSignature( { - key: "contract2", - sortKey: - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", + key: 'contract2', + sortKey: '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' }, - "asd", - "asd" + 'asd', + 'asd' ); expect( await sut.get( new CacheKey( - "contract2", - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract2', + '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ) ).toEqual({ - sortKey: - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract2:sortKey1" }), + sortKey: '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract2:sortKey1' }) }); expect( await sut.get( new CacheKey( - "contract1", - "000000860514,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract1', + '000000860514,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ) ).toEqual({ - sortKey: - "000000860514,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract1:sortKey2" }), + sortKey: '000000860514,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract1:sortKey2' }) }); expect( await sut.get( new CacheKey( - "contract0", - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract0', + '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ) ).toEqual({ - sortKey: - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract0:sortKey0" }), + sortKey: '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract0:sortKey0' }) }); expect( await sut.get( new CacheKey( - "contract0", - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b766" + 'contract0', + '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b766' ) ) ).toEqual(null); expect( await sut.get( new CacheKey( - "contract2", - "000000860514,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract2', + '000000860514,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ) ).toEqual(null); expect( await sut.get( new CacheKey( - "contract1", - "000000860516,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract1', + '000000860516,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ) ).toEqual(null); expect( await sut.getLessOrEqual( - "contract2", - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract2', + '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ).toEqual({ - sortKey: - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract2:sortKey1" }), + sortKey: '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract2:sortKey1' }) }); expect( await sut.getLessOrEqual( - "contract2", - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b768" + 'contract2', + '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b768' ) ).toEqual({ - sortKey: - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract2:sortKey1" }), + sortKey: '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract2:sortKey1' }) }); expect( await sut.getLessOrEqual( - "contract2", - "000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b766" + 'contract2', + '000000860513,1643210931888,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b766' ) ).toEqual(null); expect( await sut.getLessOrEqual( - "contract1", - "000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract1', + '000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ).toEqual({ - sortKey: - "000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract1:sortKey1" }), + sortKey: '000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract1:sortKey1' }) }); expect( await sut.getLessOrEqual( - "contract1", - "000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b766" + 'contract1', + '000000860513,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b766' ) ).toEqual(null); expect( await sut.getLessOrEqual( - "contract0", - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b768" + 'contract0', + '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b768' ) ).toEqual({ - sortKey: - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract0:sortKey0" }), + sortKey: '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract0:sortKey0' }) }); expect( await sut.getLessOrEqual( - "contract0", - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767" + 'contract0', + '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767' ) ).toEqual({ - sortKey: - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767", - cachedValue: evalState({ result: "contract0:sortKey0" }), + sortKey: '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767', + cachedValue: evalState({ result: 'contract0:sortKey0' }) }); expect( await sut.getLessOrEqual( - "contract0", - "000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b765" + 'contract0', + '000000860512,1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b765' ) ).toEqual(null); @@ -192,7 +178,7 @@ describe("Postgres cache", () => { await sut.close(); }); - it("respects limits for max interactions per contract", async () => { + it('respects limits for max interactions per contract', async () => { const max = 10; const sut = await contractCache(0, 0, max); @@ -200,7 +186,7 @@ describe("Postgres cache", () => { await sut.put( { key: getContractId(0), - sortKey: getSortKey(j), + sortKey: getSortKey(j) }, evalState({ result: `contract${0}:${j}` }) ); @@ -208,9 +194,7 @@ describe("Postgres cache", () => { // All entries are available for (let j = 0; j < max; ++j) { - const result = await sut.get( - new CacheKey(getContractId(0), getSortKey(j)) - ); + const result = await sut.get(new CacheKey(getContractId(0), getSortKey(j))); expect(result).toBeTruthy(); expect(result?.cachedValue.state.result).toBe(`contract${0}:${j}`); } @@ -219,15 +203,13 @@ describe("Postgres cache", () => { await sut.put( { key: getContractId(0), - sortKey: getSortKey(max), + sortKey: getSortKey(max) }, evalState({ result: `contract${0}:${max}` }) ); for (let i = 0; i <= max; i++) { - const result = await sut.get( - new CacheKey(getContractId(0), getSortKey(i)) - ); + const result = await sut.get(new CacheKey(getContractId(0), getSortKey(i))); if (i == 0) { expect(result).toBeFalsy(); } else { @@ -240,15 +222,13 @@ describe("Postgres cache", () => { await sut.put( { key: getContractId(0), - sortKey: getSortKey(max + 1), + sortKey: getSortKey(max + 1) }, evalState({ result: `contract${0}:${max + 1}` }) ); for (let i = 0; i <= max + 1; i++) { - const result = await sut.get( - new CacheKey(getContractId(0), getSortKey(i)) - ); + const result = await sut.get(new CacheKey(getContractId(0), getSortKey(i))); if (i <= 1) { expect(result).toBeFalsy(); } else { @@ -260,40 +240,34 @@ describe("Postgres cache", () => { await sut.close(); }); - it("should keep the latest insert, even it is the smallest one", async () => { + it('should keep the latest insert, even it is the smallest one', async () => { const sut = await contractCache(0, 0, 2); await sut.put( { key: getContractId(0), - sortKey: getSortKey(5), + sortKey: getSortKey(5) }, evalState({ result: `contract5` }) ); await sut.put( { key: getContractId(0), - sortKey: getSortKey(7), + sortKey: getSortKey(7) }, evalState({ result: `contract7` }) ); await sut.put( { key: getContractId(0), - sortKey: getSortKey(2), + sortKey: getSortKey(2) }, evalState({ result: `contract2` }) ); - const result5 = await sut.get( - new CacheKey(getContractId(0), getSortKey(5)) - ); - const result7 = await sut.get( - new CacheKey(getContractId(0), getSortKey(7)) - ); - const result2 = await sut.get( - new CacheKey(getContractId(0), getSortKey(2)) - ); + const result5 = await sut.get(new CacheKey(getContractId(0), getSortKey(5))); + const result7 = await sut.get(new CacheKey(getContractId(0), getSortKey(7))); + const result2 = await sut.get(new CacheKey(getContractId(0), getSortKey(2))); expect(result5).toBeFalsy(); expect(result7).toBeTruthy(); diff --git a/src/__tests__/pg-sort-key-cache-commit-rollback.test.ts b/src/__tests__/pg-sort-key-cache-commit-rollback.test.ts index c0485f7..c7eee55 100644 --- a/src/__tests__/pg-sort-key-cache-commit-rollback.test.ts +++ b/src/__tests__/pg-sort-key-cache-commit-rollback.test.ts @@ -1,65 +1,57 @@ -import { CacheKey } from "warp-contracts"; -import { getSortKey, sortKeyCache } from "./utils"; -import { PgSortKeyCache } from "../PgSortKeyCache"; +import { CacheKey } from 'warp-contracts'; +import { getSortKey, sortKeyCache } from './utils'; +import { PgSortKeyCache } from '../PgSortKeyCache'; let sut: PgSortKeyCache; beforeAll(async () => { sut = await sortKeyCache(100); -}) +}); -describe('Postgres sort key cache transactions testing', () => { +describe('Postgres cache batch', () => { it('access range keys during active transaction and commit', async () => { await sut.open(); const sortKey = 343; await sut.begin(); - await sut.put(new CacheKey("key.one", getSortKey(sortKey)), 1); - await sut.put(new CacheKey("key.two", getSortKey(sortKey)), 2); + await sut.put(new CacheKey('key.one', getSortKey(sortKey)), 1); + await sut.put(new CacheKey('key.two', getSortKey(sortKey)), 2); const transactionKeys = await sut.keys(getSortKey(sortKey)); - expect(transactionKeys).toContain("key.one"); - expect(transactionKeys).toContain("key.two"); + expect(transactionKeys).toContain('key.one'); + expect(transactionKeys).toContain('key.two'); - const kvKeys = Array.from( - ( - await sut.kvMap(getSortKey(sortKey), { gte: "key.", lt: "key.\xff" }) - ).keys() - ); - expect(kvKeys).toContain("key.one"); - expect(kvKeys).toContain("key.two"); + const kvKeys = Array.from((await sut.kvMap(getSortKey(sortKey), { gte: 'key.', lt: 'key.\xff' })).keys()); + expect(kvKeys).toContain('key.one'); + expect(kvKeys).toContain('key.two'); await sut.commit(); - expect((await sut.getLast("key.one")).cachedValue).toEqual(1); - expect((await sut.getLast("key.three"))?.cachedValue).toBeFalsy(); + expect((await sut.getLast('key.one')).cachedValue).toEqual(1); + expect((await sut.getLast('key.three'))?.cachedValue).toBeFalsy(); await sut.close(); }); - it("keys order natural and reversed", async () => { + it('keys order natural and reversed', async () => { await sut.open(); const sortKey = 348; await sut.begin(); - await sut.put(new CacheKey("user.11", getSortKey(sortKey)), 2); - await sut.put(new CacheKey("user.12", getSortKey(sortKey)), 2); - await sut.put(new CacheKey("user.13", getSortKey(sortKey)), 2); - await sut.put(new CacheKey("user.14", getSortKey(sortKey)), 2); - await sut.put(new CacheKey("user.15", getSortKey(sortKey)), 2); + await sut.put(new CacheKey('user.11', getSortKey(sortKey)), 2); + await sut.put(new CacheKey('user.12', getSortKey(sortKey)), 2); + await sut.put(new CacheKey('user.13', getSortKey(sortKey)), 2); + await sut.put(new CacheKey('user.14', getSortKey(sortKey)), 2); + await sut.put(new CacheKey('user.15', getSortKey(sortKey)), 2); - const naturalOrder = Array.from( - ( - await sut.kvMap(getSortKey(sortKey), { gte: "user.11", lt: "user.14" }) - ).keys() - ); + const naturalOrder = Array.from((await sut.kvMap(getSortKey(sortKey), { gte: 'user.11', lt: 'user.14' })).keys()); const reverseOrder = Array.from( ( await sut.kvMap(getSortKey(sortKey), { - gte: "user.11", - lt: "user.14", - reverse: true, + gte: 'user.11', + lt: 'user.14', + reverse: true }) ).keys() ); @@ -68,97 +60,93 @@ describe('Postgres sort key cache transactions testing', () => { await sut.commit(); await sut.begin(); - await sut.del(new CacheKey("user.12", getSortKey(sortKey))); + await sut.del(new CacheKey('user.12', getSortKey(sortKey))); const items = Array.from( ( await sut.kvMap(getSortKey(sortKey), { - gte: "user.11", - lt: "user.14", - reverse: true, + gte: 'user.11', + lt: 'user.14', + reverse: true }) ).keys() ); - expect(items).toEqual(["user.13", "user.11"]); + expect(items).toEqual(['user.13', 'user.11']); await sut.commit(); await sut.close(); }); - it("access range keys during active transaction and rollback", async () => { + it('access range keys during active transaction and rollback', async () => { await sut.open(); const sortKey = 384; await sut.begin(); - await sut.put(new CacheKey("key.one", getSortKey(sortKey)), 11); - await sut.put(new CacheKey("key.three", getSortKey(sortKey)), 3); - await sut.del(new CacheKey("key.two", getSortKey(sortKey))); + await sut.put(new CacheKey('key.one', getSortKey(sortKey)), 11); + await sut.put(new CacheKey('key.three', getSortKey(sortKey)), 3); + await sut.del(new CacheKey('key.two', getSortKey(sortKey))); const transactionKeys = await sut.keys(getSortKey(sortKey)); - expect(transactionKeys).toContain("key.one"); - expect(transactionKeys).toContain("key.three"); + expect(transactionKeys).toContain('key.one'); + expect(transactionKeys).toContain('key.three'); - const kvKeys = Array.from( - ( - await sut.kvMap(getSortKey(sortKey), { gte: "key.", lt: "key.\xff" }) - ).keys() - ); - expect(kvKeys).toContain("key.one"); - expect(kvKeys).toContain("key.three"); + const kvKeys = Array.from((await sut.kvMap(getSortKey(sortKey), { gte: 'key.', lt: 'key.\xff' })).keys()); + expect(kvKeys).toContain('key.one'); + expect(kvKeys).toContain('key.three'); - expect((await sut.getLast("key.one")).cachedValue).toEqual(11); - expect((await sut.getLast("key.two"))?.cachedValue).toBeFalsy(); - expect((await sut.getLast("key.three")).cachedValue).toEqual(3); + expect((await sut.getLast('key.one')).cachedValue).toEqual(11); + expect((await sut.getLast('key.two'))?.cachedValue).toBeFalsy(); + expect((await sut.getLast('key.three')).cachedValue).toEqual(3); await sut.rollback(); - expect((await sut.getLast("key.one")).cachedValue).toEqual(1); - expect((await sut.getLast("key.two")).cachedValue).toEqual(2); - expect((await sut.getLast("key.three"))?.cachedValue).toBeFalsy(); + expect((await sut.getLast('key.one')).cachedValue).toEqual(1); + expect((await sut.getLast('key.two')).cachedValue).toEqual(2); + expect((await sut.getLast('key.three'))?.cachedValue).toBeFalsy(); await sut.close(); }); - it("multiple operations", async () => { + it('multiple operations', async () => { await sut.open(); const sortKey = 395; await sut.begin(); - await sut.put(new CacheKey("key.one", getSortKey(sortKey)), 111); - await sut.put(new CacheKey("key.two", getSortKey(sortKey)), 222); - await sut.put(new CacheKey("key.four", getSortKey(sortKey)), 333); - await sut.put(new CacheKey("key.five", getSortKey(sortKey)), 333); + await sut.put(new CacheKey('key.one', getSortKey(sortKey)), 111); + await sut.put(new CacheKey('key.two', getSortKey(sortKey)), 222); + await sut.put(new CacheKey('key.four', getSortKey(sortKey)), 333); + await sut.put(new CacheKey('key.five', getSortKey(sortKey)), 333); - await sut.del(new CacheKey("key.two", getSortKey(sortKey))); - await sut.del(new CacheKey("key.fa", getSortKey(sortKey))); + await sut.del(new CacheKey('key.two', getSortKey(sortKey))); + await sut.del(new CacheKey('key.fa', getSortKey(sortKey))); const transactionKeys = await sut.keys(getSortKey(sortKey)); - expect(transactionKeys).toContain("key.one"); - expect(transactionKeys).toContain("key.four"); + expect(transactionKeys).toContain('key.one'); + expect(transactionKeys).toContain('key.four'); const kvKeys = Array.from( ( await sut.kvMap(getSortKey(sortKey), { - gte: "key.", - lt: "key.\xff", - limit: 2, + gte: 'key.', + lt: 'key.\xff', + limit: 2 }) ).keys() ); - expect(kvKeys).toEqual(["key.five", "key.four"]); + expect(kvKeys).toEqual(['key.five', 'key.four']); await sut.rollback(); const rollbackKeys = Array.from( ( await sut.kvMap(getSortKey(sortKey), { - gte: "key.", - lt: "key.\xff", - reverse: true, + gte: 'key.', + lt: 'key.\xff', + reverse: true }) ).keys() ); - expect(rollbackKeys).toEqual(["key.two", "key.one"]); + expect(rollbackKeys).toEqual(['key.two', 'key.one']); await sut.drop(); await sut.close(); diff --git a/src/__tests__/utils.ts b/src/__tests__/utils.ts index a812a6b..8dd3614 100644 --- a/src/__tests__/utils.ts +++ b/src/__tests__/utils.ts @@ -1,18 +1,13 @@ -import { PgContractCache } from "../PgContractCache"; -import { PgContractCacheOptions } from "../PgContractCacheOptions"; -import { EvalStateResult } from "warp-contracts"; -import { PgSortKeyCacheOptions } from "../PgSortKeyCacheOptions"; -import { PgSortKeyCache } from "../PgSortKeyCache"; +import { PgContractCache } from '../PgContractCache'; +import { PgContractCacheOptions } from '../PgContractCacheOptions'; +import { EvalStateResult } from 'warp-contracts'; +import { PgSortKeyCacheOptions } from '../PgSortKeyCacheOptions'; +import { PgSortKeyCache } from '../PgSortKeyCache'; -export const getContractId = (i: number) => `contract${i}`.padStart(43, "0"); +export const getContractId = (i: number) => `contract${i}`.padStart(43, '0'); export const getSortKey = (j: number) => - `${j - .toString() - .padStart( - 12, - "0" - )},1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767`; + `${j.toString().padStart(12, '0')},1643210931796,81e1bea09d3262ee36ce8cfdbbb2ce3feb18a717c3020c47d206cb8ecb43b767`; export const contractCache = async function ( numContracts: number, @@ -37,7 +32,7 @@ export const contractCache = async function ( await sut.put( { key: getContractId(i), - sortKey: getSortKey(j), + sortKey: getSortKey(j) }, evalState(`{ "contract${i}":"${j}" }`) ); @@ -52,7 +47,7 @@ export const sortKeyCache = async function ( maxEntries?: number ): Promise> { const pgOptions: PgSortKeyCacheOptions = { - tableName: "kiwi", + tableName: 'kiwi', minEntriesPerKey: maxEntries || 100 * numRepeatingEntries, maxEntriesPerKey: maxEntries || 100 * numRepeatingEntries, user: 'postgres', diff --git a/src/index.ts b/src/index.ts index 977fcd9..06b948b 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,5 +1,5 @@ -export * from "./PgContractCacheOptions"; -export * from "./PgContractCache"; +export * from './PgContractCacheOptions'; +export * from './PgContractCache'; -export * from "./PgSortKeyCacheOptions"; -export * from "./PgSortKeyCache"; +export * from './PgSortKeyCacheOptions'; +export * from './PgSortKeyCache';