Big News: Socket raises $60M Series C at a $1B valuation to secure software supply chains for AI-driven development.Announcement →

@binaris/shift-db

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@binaris/shift-db - npm Package Compare versions

Comparing version

0.3.1

0.4.0-dbnu

.tern-port

Sorry, the diff of this file is not supported yet

+8

db-client.build.error.log

		DEBUG: loaded
		DEBUG: start before
		DEBUG: tmpdir /var/folders/k7/8lqpw3ws3ybd5_rm_1jvzlj00000gn/T/test-state-ZB8J5q
		DEBUG: listening on undefined
		DEBUG: started { ctx:
		{ dbDir:
		'/var/folders/k7/8lqpw3ws3ybd5_rm_1jvzlj00000gn/T/test-state-ZB8J5q',
		client: DBHandler { ctx: [Object], client: [DBClient] } } }

+2

db-client.build.log

		>>> @binaris/shift-db
		rm -rf dist/ && tsc

+2

dist/test/component/db.d.ts

		export {};
		//# sourceMappingURL=db.d.ts.map

+1

dist/test/component/db.d.ts.map

{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../../src/test/component/db.ts"],"names":[],"mappings":""}

+182

dist/test/component/db.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		var __importStar = (this && this.__importStar) \|\| function (mod) {
		if (mod && mod.__esModule) return mod;
		var result = {};
		if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
		result["default"] = mod;
		return result;
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const ava_1 = __importDefault(require("ava"));
		const shift_leveldb_server_1 = require("@binaris/shift-leveldb-server");
		const shift_interfaces_koa_server_1 = require("@binaris/shift-interfaces-koa-server");
		const __1 = require("../..");
		const fs_1 = require("fs");
		const rmfr_1 = __importDefault(require("rmfr"));
		const os_1 = require("os");
		const util_1 = require("util");
		const path = __importStar(require("path"));
		const koa_1 = __importDefault(require("koa"));
		const koa_router_1 = __importDefault(require("koa-router"));
		const http_1 = require("http");
		const test = ava_1.default;
		async function listenOn(app) {
		return new Promise((resolve, reject) => {
		const server = http_1.createServer(app.callback())
		.listen(undefined, 'localhost', () => resolve(server));
		server.once('error', reject);
		});
		}
		process.env.APP_ID = 'testing';
		process.env.API_KEY = '1234';
		test.beforeEach(async (t) => {
		const dbDir = await util_1.promisify(fs_1.mkdtemp)(path.join(os_1.tmpdir(), 'test-state-'), 'utf8');
		const db = new shift_leveldb_server_1.DB(`${dbDir}/root.db`);
		const dbRouter = new shift_interfaces_koa_server_1.DBRouter(db, true);
		const router = new koa_router_1.default();
		router.use('/v1', dbRouter.koaRouter.routes(), dbRouter.koaRouter.allowedMethods());
		const app = new koa_1.default();
		app.use(router.routes());
		app.use(router.allowedMethods());
		const server = await listenOn(app);
		const port = server.address().port;
		const url = `http://localhost:${port}`;
		process.env.DB_BASE_URL = url;
		// Instantiate DBHandler with proper URL set up.
		const client = new __1.DBHandler({ timeoutMs: 1000 });
		t.context = {
		dbDir,
		client,
		};
		});
		test.afterEach(async (t) => {
		await rmfr_1.default(t.context.dbDir);
		});
		test('DB.get returns undefined when no key exists', async (t) => {
		const { client } = t.context;
		const value = await client.get('test');
		t.assert(value === undefined);
		});
		test('DB.create creates a new document and returns true', async (t) => {
		const { client } = t.context;
		const ret = await client.create('test', { a: 1 });
		const value = await client.get('test');
		t.deepEqual(value, { a: 1 });
		t.true(ret);
		});
		test('DB.create returns false if key already exists', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		t.false(await client.create('test', { a: 2 }));
		});
		test('DB.create throws TypeError when value forced undefined', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.create('test', undefined), {
		instanceOf: TypeError,
		message: /undefined/,
		});
		});
		test('DB.create throws TypeError when value is a function', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.create('test', () => 17), {
		instanceOf: TypeError,
		message: /function/,
		});
		});
		test('DB.create throws TypeError when value is a bigint', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.create('test', BigInt(17)), {
		instanceOf: TypeError,
		message: /bigint/,
		});
		});
		test('DB.create accepts arbitrary JSONables', async (t) => {
		const { client } = t.context;
		await client.create('test_string', 'hey');
		await client.create('test_number', 7);
		await client.create('test_boolean', true);
		await client.create('test_object', { a: [7] });
		await client.create('test_object', [{ a: 7 }]);
		t.pass();
		});
		test('DB.remove returns false when no key exists', async (t) => {
		const { client } = t.context;
		t.false(await client.remove('test'));
		});
		test('DB.remove returns false when key was already deleted', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		await client.remove('test');
		t.false(await client.remove('test'));
		});
		test('DB.remove removes existing key from DB and returns true', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		t.true(await client.remove('test'));
		t.is(await client.get('test'), undefined);
		});
		test('DB.remove removes the key', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		t.true(await client.remove('test'));
		const value = await client.get('test');
		t.assert(value === undefined);
		});
		test('DB.update creates a new document if key does not exist, returns it, sets version to 1', async (t) => {
		const { client } = t.context;
		const next = await client.update('test', (prev) => (Object.assign({}, prev, { a: 1 })));
		const value = await client.get('test');
		t.deepEqual(value, { a: 1 });
		t.deepEqual(next, value);
		});
		test('DB.update updates an existing document, returns it, and increments version', async (t) => {
		const { client } = t.context;
		await client.create('test', { b: 2 });
		const next = await client.update('test', (prev) => (Object.assign({}, prev, { a: 1 })));
		const value = await client.get('test');
		t.deepEqual(value, { a: 1, b: 2 });
		t.deepEqual(next, value);
		});
		test('DB.update does nothing if document not updated', async (t) => {
		const { client } = t.context;
		await client.create('test', { b: 2 });
		const next = await client.update('test', (prev) => (Object.assign({}, prev)));
		const value = await client.get('test');
		t.deepEqual(value, { b: 2 });
		t.deepEqual(next, value);
		// TODO(ariels): Verify no update on an ongoing poll.
		});
		// TODO(ariels): Retrieve poll tests from old db/src/db.ts.
		test('DB.create works after remove', async (t) => {
		const { client } = t.context;
		await client.create('test', 7);
		await client.remove('test');
		t.true(await client.create('test', 8));
		const value = await client.get('test');
		t.assert(value === 8);
		});
		// TODO(ariels): DB.update works after remove but increments version and includes tombstone\'s patches'
		test('DB.update throws TypeError if updater returned undefined', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.update('test', () => undefined), TypeError);
		});
		test('CLIENT.update throws TypeError if trying to modify returned object', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1, b: { c: 2, d: [5] } });
		await t.throwsAsync(client.update('test', (obj) => {
		obj.a = 2;
		return obj;
		}), TypeError);
		await t.throwsAsync(client.update('test', (obj) => {
		obj.b.c = 3;
		return obj;
		}), TypeError);
		await t.throwsAsync(client.update('test', (obj) => {
		obj.b.d[0] = 6;
		return obj;
		}), TypeError);
		});
		//# sourceMappingURL=db.js.map

+1

dist/test/component/db.js.map

+10

package-deps.json

		{
		"files": {
		"db-client/package.json": "de9cb18da4b3516fe0b763d547d9258bb65b38f0",
		"db-client/src/index.ts": "bdfd33ff816857efe5a383c2c6854faa84d12190",
		"db-client/src/test/component/db.ts": "d35a3788e8d1d3d6a42f0abd50efd9567b12bd96",
		"db-client/tsconfig.json": "383425b283005db5d0677d2116cb9b66f739985a",
		"common/config/rush/shrinkwrap.yaml": "186870aead95700ad5d3b6e82e261de5621bf26b"
		},
		"arguments": "rm -rf dist/ && tsc "
		}

package.json~

Sorry, the diff of this file is not supported yet

+170

src/index.ts

		import { DBClient, Options } from '@binaris/shift-interfaces-node-client';
		import {
		ClientContext, UpdateOptions, Version, VersionedMaybeObject, Serializable
		} from '@binaris/shift-interfaces-node-client/interfaces';
		import deepFreeze, { DeepReadonly } from 'deep-freeze';
		import { merge } from 'ramda';
		import * as process from 'process';

		export interface Versioned<T extends Serializable \| undefined> {
		version: Version;
		value: T;
		}

		const defaultOptions: Options = {
		timeoutMs: 2000,
		};

		// bigint not currently allowed.
		const allowedTypes = new Set(['object', 'boolean', 'number', 'string']);

		function checkValue(value: Serializable) {
		if (!allowedTypes.has(typeof value)) {
		throw new TypeError(`Non-JSONable value of type ${typeof value} at top level`);
		}
		}

		// Generates successive promises to sleep in order to back off. (Not
		// an async iterator, so you can generate the promise to back off,
		// then try something, and then back off for the remainder of the
		// generated time.)
		function* backoff() {
		let delayMs = 20;
		for (;;) {
		yield new Promise((res) => setTimeout(res, delayMs));
		delayMs *= 1.2;
		}
		}

		export class DBHandler {
		private readonly client: DBClient;
		private readonly ctx: ClientContext = {
		auth: {
		v1: {
		// TODO(ariels): Update with prefixes from binaris/spice#616.
		appId: process.env.APP_ID!,
		apiKey: process.env.API_KEY!,
		},
		},
		};

		constructor(options?: Options) {
		this.client = new DBClient(`${process.env.DB_BASE_URL!}/v1`, merge(defaultOptions, options));
		}

		public async get<T extends Serializable = any>(key: string): Promise<T \| undefined> {
		return (await this.client.get(this.ctx, key)) as T;
		}

		public async create(key: string, value: Serializable): Promise<boolean> {
		checkValue(value);
		return await this.client.create(this.ctx, key, value);
		}

		public async remove(key: string): Promise<boolean> {
		return await this.client.remove(this.ctx, key);
		}

		// TODO(ariels): Support operationId for streaming.
		public async update<T extends Serializable = any>(
		key: string, updater: (state?: DeepReadonly<T>) => T, _options?: UpdateOptions,
		): Promise<DeepReadonly<T>> {
		for (const delay of backoff()) {
		const { value, version } = await this.getWithVersion(key);
		// deepFreeze doesn't like some values (like undefined), trick
		// it by referring to value in an object.
		const newValue = updater(deepFreeze({ value: value as T }).value);
		checkValue(newValue);
		if (await this.setIfVersion(key, newValue, version)) return deepFreeze(newValue);
		await delay;
		}
		throw Error('Timed out'); // backoff() is currently infinite but
		// won't stay that way. Needed for
		// TypeScript.
		}

		private getWithVersion(key: string): Promise<VersionedMaybeObject> {
		return this.client.getWithVersion(this.ctx, key);
		}

		public async startPolling<T extends Serializable = any>(_key: string): Promise<Versioned<T \| undefined>> {
		throw new Error('Unimplemented');
		}

		public async find(): Promise<any[]> {
		throw new Error('Unimplemented');
		}

		private async setIfVersion(
		key: string,
		value: Serializable,
		version: Version
		): Promise<boolean> {
		return await this.client.setIfVersion(this.ctx, key, version, value);
		}
		}

		const db = new DBHandler();

		/**
		* Gets a single document.
		* @return - value or undefined if key doesn’t exist.
		*/
		export async function get<T extends Serializable = any>(key: string): Promise<T \| undefined> {
		return await db.get(key);
		}

		/**
		* Creates a document for given key.
		* @param value - Cannot be undefined, must be an object
		* @return - true if document was created, false if key already exists.
		*/
		export async function create(key: string, value: Serializable): Promise<boolean> {
		return await db.create(key, value);
		}

		/**
		* Removes a single document.
		* @return - true if document was deleted, false if key doesn’t exist.
		*/
		export async function remove(key: string): Promise<boolean> {
		return await db.remove(key);
		}

		/**
		* Updates a single document.
		* @param updater - Function that gets the previous value and returns the next value to update the DB with.
		* Cannot return undefined, receives undefined in case key doesn’t already exist in the DB.
		* @return - The new value returned from updater
		*/
		export async function update<T extends Serializable = any>(
		key: string, updater: (state?: DeepReadonly<T>) => T, options?: UpdateOptions,
		): Promise<DeepReadonly<T>> {
		return await db.update(key, updater, options);
		}
		// Available only on backend, needs to pass a function.

		/**
		* Find documents matching query.
		* @param query - a query constructed with Q methods.
		* @return - an array of documents
		*/
		export async function find(): Promise<any[]> {
		throw new Error('Unimplemented');
		}

		/**
		* Polls on updates to specified keys since specified versions.
		*/
		export async function poll(): Promise<any> {
		throw new Error('Unimplemented');
		}
		poll.__shiftjs__ = { exposed: true };

		/**
		* Gets a initial document in an intent to for poll on it.
		*/
		export async function startPolling<T extends Serializable = any>(_key: string): Promise<Versioned<T \| undefined>> {
		throw new Error('Unimplemented');
		}
		startPolling.__shiftjs__ = { exposed: true };

src/index.ts~

Sorry, the diff of this file is not supported yet

+200

src/test/component/db.ts

		import anyTest, { TestInterface } from 'ava';
		import { DB } from '@binaris/shift-leveldb-server';
		import { DBRouter } from '@binaris/shift-interfaces-koa-server';
		import { DBHandler } from '../..';
		import { mkdtemp } from 'fs';
		import rmrf from 'rmfr';
		import { tmpdir } from 'os';
		import { promisify } from 'util';
		import * as path from 'path';
		import { AddressInfo } from 'net';
		import Koa from 'koa';
		import KoaRouter from 'koa-router';
		import { createServer, Server } from 'http';

		interface Context {
		dbDir: string;
		client: DBHandler;
		}

		const test = anyTest as TestInterface<Context>;

		async function listenOn(app: Koa): Promise<Server> {
		return new Promise((resolve, reject) => {
		const server = createServer(app.callback())
		.listen(undefined, 'localhost', () => resolve(server));
		server.once('error', reject);
		});
		}

		process.env.APP_ID = 'testing';
		process.env.API_KEY = '1234';

		test.beforeEach(async (t) => {
		const dbDir = await promisify(mkdtemp)(path.join(tmpdir(), 'test-state-'), 'utf8');
		const db = new DB(`${dbDir}/root.db`);
		const dbRouter = new DBRouter(db, true);
		const router = new KoaRouter();
		router.use('/v1', dbRouter.koaRouter.routes(), dbRouter.koaRouter.allowedMethods());
		const app = new Koa();
		app.use(router.routes());
		app.use(router.allowedMethods());

		const server = await listenOn(app);
		const port = (server.address() as unknown as AddressInfo).port;
		const url = `http://localhost:${port}`;
		process.env.DB_BASE_URL = url;
		// Instantiate DBHandler with proper URL set up.
		const client = new DBHandler({ timeoutMs: 1000 });
		t.context = {
		dbDir,
		client,
		};
		});

		test.afterEach(async (t) => {
		await rmrf(t.context.dbDir);
		});

		test('DB.get returns undefined when no key exists', async (t) => {
		const { client } = t.context;
		const value = await client.get('test');
		t.assert(value === undefined);
		});

		test('DB.create creates a new document and returns true', async (t) => {
		const { client } = t.context;
		const ret = await client.create('test', { a: 1 });
		const value = await client.get('test');
		t.deepEqual(value, { a: 1 });
		t.true(ret);
		});

		test('DB.create returns false if key already exists', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		t.false(await client.create('test', { a: 2 }));
		});

		test('DB.create throws TypeError when value forced undefined', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.create('test', undefined as any), {
		instanceOf: TypeError,
		message: /undefined/,
		});
		});

		test('DB.create throws TypeError when value is a function', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.create('test', () => 17), {
		instanceOf: TypeError,
		message: /function/,
		});
		});

		test('DB.create throws TypeError when value is a bigint', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.create('test', BigInt(17)), {
		instanceOf: TypeError,
		message: /bigint/,
		});
		});

		test('DB.create accepts arbitrary JSONables', async (t) => {
		const { client } = t.context;
		await client.create('test_string', 'hey');
		await client.create('test_number', 7);
		await client.create('test_boolean', true);
		await client.create('test_object', { a: [7] });
		await client.create('test_object', [{ a: 7 }]);
		t.pass();
		});

		test('DB.remove returns false when no key exists', async (t) => {
		const { client } = t.context;
		t.false(await client.remove('test'));
		});

		test('DB.remove returns false when key was already deleted', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		await client.remove('test');
		t.false(await client.remove('test'));
		});

		test('DB.remove removes existing key from DB and returns true', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		t.true(await client.remove('test'));
		t.is(await client.get('test'), undefined);
		});

		test('DB.remove removes the key', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1 });
		t.true(await client.remove('test'));
		const value = await client.get('test');
		t.assert(value === undefined);
		});

		test('DB.update creates a new document if key does not exist, returns it, sets version to 1', async (t) => {
		const { client } = t.context;
		const next = await client.update('test', (prev) => ({ ...prev, a: 1 }));
		const value = await client.get('test');
		t.deepEqual(value, { a: 1 });
		t.deepEqual(next, value);
		});

		test('DB.update updates an existing document, returns it, and increments version', async (t) => {
		const { client } = t.context;
		await client.create('test', { b: 2 });
		const next = await client.update('test', (prev) => ({ ...prev, a: 1 }));
		const value = await client.get('test');
		t.deepEqual(value, { a: 1, b: 2 });
		t.deepEqual(next, value);
		});

		test('DB.update does nothing if document not updated', async (t) => {
		const { client } = t.context;
		await client.create('test', { b: 2 });
		const next = await client.update('test', (prev) => ({ ...prev }));
		const value = await client.get('test');
		t.deepEqual(value, { b: 2 });
		t.deepEqual(next, value);
		// TODO(ariels): Verify no update on an ongoing poll.
		});

		// TODO(ariels): Retrieve poll tests from old db/src/db.ts.

		test('DB.create works after remove', async (t) => {
		const { client } = t.context;
		await client.create('test', 7);
		await client.remove('test');
		t.true(await client.create('test', 8));
		const value = await client.get('test');
		t.assert(value === 8);
		});

		// TODO(ariels): DB.update works after remove but increments version and includes tombstone\'s patches'

		test('DB.update throws TypeError if updater returned undefined', async (t) => {
		const { client } = t.context;
		await t.throwsAsync(client.update('test', () => undefined as any), TypeError);
		});

		test('CLIENT.update throws TypeError if trying to modify returned object', async (t) => {
		const { client } = t.context;
		await client.create('test', { a: 1, b: { c: 2, d: [5] } });
		await t.throwsAsync(client.update('test', (obj) => {
		(obj as any).a = 2;
		return obj;
		}), TypeError);
		await t.throwsAsync(client.update('test', (obj) => {
		(obj as any).b.c = 3;
		return obj;
		}), TypeError);
		await t.throwsAsync(client.update('test', (obj) => {
		(obj as any).b.d[0] = 6;
		return obj;
		}), TypeError);
		});

src/test/component/db.ts~

Sorry, the diff of this file is not supported yet

+6

tsconfig.json

		{
		"extends": "../common/tsconfig.json",
		"compilerOptions": {
		"outDir": "dist",
		}
		}

tsconfig.json~

Sorry, the diff of this file is not supported yet

+23

-7

dist/index.d.ts

		@@ -1,5 +0,21 @@
		/// <reference types="deep-freeze" />
		import { Q, Serializable, Document, DeepReadonly, UpdateOptions, KeyedPatches, KeyedVersions, Versioned } from './db';
		export { Serializable, Q, Document, DeepReadonly, UpdateOptions, Versioned };
		export { ValueError } from './errors';
		import { Options } from '@binaris/shift-interfaces-node-client';
		import { UpdateOptions, Version, Serializable } from '@binaris/shift-interfaces-node-client/interfaces';
		import { DeepReadonly } from 'deep-freeze';
		export interface Versioned<T extends Serializable \| undefined> {
		version: Version;
		value: T;
		}
		export declare class DBHandler {
		private readonly client;
		private readonly ctx;
		constructor(options?: Options);
		get<T extends Serializable = any>(key: string): Promise<T \| undefined>;
		create(key: string, value: Serializable): Promise<boolean>;
		remove(key: string): Promise<boolean>;
		update<T extends Serializable = any>(key: string, updater: (state?: DeepReadonly<T>) => T, _options?: UpdateOptions): Promise<DeepReadonly<T>>;
		private getWithVersion;
		startPolling<T extends Serializable = any>(_key: string): Promise<Versioned<T \| undefined>>;
		find(): Promise<any[]>;
		private setIfVersion;
		}
		/**
		@@ -33,7 +49,7 @@ * Gets a single document.
		*/
		export declare function find(query: Q.Query): Promise<Document[]>;
		export declare function find(): Promise<any[]>;
		/**
		* Polls on updates to specified keys since specified versions.
		*/
		export declare function poll(keysToVersions: KeyedVersions): Promise<KeyedPatches>;
		export declare function poll(): Promise<any>;
		export declare namespace poll {
		@@ -47,3 +63,3 @@ var __shiftjs__: {
		*/
		export declare function startPolling<T extends Serializable = any>(key: string): Promise<Versioned<T \| undefined>>;
		export declare function startPolling<T extends Serializable = any>(_key: string): Promise<Versioned<T \| undefined>>;
		export declare namespace startPolling {
		@@ -50,0 +66,0 @@ var __shiftjs__: {

+1

-1

dist/index.d.ts.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAEL,CAAC,EACD,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,aAAa,EACb,SAAS,EACV,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,YAAY,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAStC;;;GAGG;AACH,wBAAsB,GAAG,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAE3F;AAED;;;;GAIG;AACH,wBAAsB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAE/E;AAED;;;GAGG;AACH,wBAAsB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE1D;AAED;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EACvD,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,GAC5E,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE1B;AAED;;;;GAIG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAE9D;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,cAAc,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAE/E;yBAFqB,IAAI;;;;;AAK1B;;GAEG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAa/G;yBAbqB,YAAY"}
		{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,EACU,aAAa,EAAE,OAAO,EAAwB,YAAY,EAC1E,MAAM,kDAAkD,CAAC;AAC1D,OAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIvD,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,YAAY,GAAG,SAAS;IAC3D,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV;AA2BD,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAQlB;gBAEU,OAAO,CAAC,EAAE,OAAO;IAIhB,GAAG,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAItE,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAK1D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKrC,MAAM,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EAC9C,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,EAAE,aAAa,GAC7E,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAe3B,OAAO,CAAC,cAAc;IAIT,YAAY,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAI3F,IAAI,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;YAIrB,YAAY;CAO3B;AAID;;;GAGG;AACH,wBAAsB,GAAG,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAE3F;AAED;;;;GAIG;AACH,wBAAsB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAE/E;AAED;;;GAGG;AACH,wBAAsB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE1D;AAED;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EACvD,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,GAC5E,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE1B;AAGD;;;;GAIG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,CAE3C;AAED;;GAEG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,CAEzC;yBAFqB,IAAI;;;;;AAK1B;;GAEG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,YAAY,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAEhH;yBAFqB,YAAY"}

+95

-25

dist/index.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		var __importStar = (this && this.__importStar) \|\| function (mod) {
		if (mod && mod.__esModule) return mod;
		var result = {};
		if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
		result["default"] = mod;
		return result;
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const db_1 = require("./db");
		exports.Q = db_1.Q;
		var errors_1 = require("./errors");
		exports.ValueError = errors_1.ValueError;
		const dbPath = process.env.SHIFT_DB_PATH;
		if (!dbPath) {
		throw new Error('SHIFT_DB_PATH env var not defined');
		const shift_interfaces_node_client_1 = require("@binaris/shift-interfaces-node-client");
		const deep_freeze_1 = __importDefault(require("deep-freeze"));
		const ramda_1 = require("ramda");
		const process = __importStar(require("process"));
		const defaultOptions = {
		timeoutMs: 2000,
		};
		// bigint not currently allowed.
		const allowedTypes = new Set(['object', 'boolean', 'number', 'string']);
		function checkValue(value) {
		if (!allowedTypes.has(typeof value)) {
		throw new TypeError(`Non-JSONable value of type ${typeof value} at top level`);
		}
		}
		const db = new db_1.DB(dbPath);
		// Generates successive promises to sleep in order to back off. (Not
		// an async iterator, so you can generate the promise to back off,
		// then try something, and then back off for the remainder of the
		// generated time.)
		function* backoff() {
		let delayMs = 20;
		for (;;) {
		yield new Promise((res) => setTimeout(res, delayMs));
		delayMs *= 1.2;
		}
		}
		class DBHandler {
		constructor(options) {
		this.ctx = {
		auth: {
		v1: {
		// TODO(ariels): Update with prefixes from binaris/spice#616.
		appId: process.env.APP_ID,
		apiKey: process.env.API_KEY,
		},
		},
		};
		this.client = new shift_interfaces_node_client_1.DBClient(`${process.env.DB_BASE_URL}/v1`, ramda_1.merge(defaultOptions, options));
		}
		async get(key) {
		return (await this.client.get(this.ctx, key));
		}
		async create(key, value) {
		checkValue(value);
		return await this.client.create(this.ctx, key, value);
		}
		async remove(key) {
		return await this.client.remove(this.ctx, key);
		}
		// TODO(ariels): Support operationId for streaming.
		async update(key, updater, _options) {
		for (const delay of backoff()) {
		const { value, version } = await this.getWithVersion(key);
		// deepFreeze doesn't like some values (like undefined), trick
		// it by referring to value in an object.
		const newValue = updater(deep_freeze_1.default({ value: value }).value);
		checkValue(newValue);
		if (await this.setIfVersion(key, newValue, version))
		return deep_freeze_1.default(newValue);
		await delay;
		}
		throw Error('Timed out'); // backoff() is currently infinite but
		// won't stay that way. Needed for
		// TypeScript.
		}
		getWithVersion(key) {
		return this.client.getWithVersion(this.ctx, key);
		}
		async startPolling(_key) {
		throw new Error('Unimplemented');
		}
		async find() {
		throw new Error('Unimplemented');
		}
		async setIfVersion(key, value, version) {
		return await this.client.setIfVersion(this.ctx, key, version, value);
		}
		}
		exports.DBHandler = DBHandler;
		const db = new DBHandler();
		/**
		@@ -47,2 +127,3 @@ * Gets a single document.
		exports.update = update;
		// Available only on backend, needs to pass a function.
		/**
		@@ -53,4 +134,4 @@ * Find documents matching query.
		*/
		async function find(query) {
		return await db.find(query);
		async function find() {
		throw new Error('Unimplemented');
		}
		@@ -61,4 +142,4 @@ exports.find = find;
		*/
		async function poll(keysToVersions) {
		return await db.poll(keysToVersions);
		async function poll() {
		throw new Error('Unimplemented');
		}
		@@ -70,15 +151,4 @@ exports.poll = poll;
		*/
		async function startPolling(key) {
		const doc = await db.getWithMeta(key);
		if (doc === undefined) {
		return {
		// Once a document is created its version is bound to be greater than this.
		version: { major: 0, minor: 0 },
		value: undefined,
		};
		}
		return {
		version: doc.version,
		value: doc.value,
		};
		async function startPolling(_key) {
		throw new Error('Unimplemented');
		}
		@@ -85,0 +155,0 @@ exports.startPolling = startPolling;

+1

-1

dist/index.js.map

		@@ -1,1 +0,1 @@
		{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAAA,6BAUc;AAES,YAVrB,MAAC,CAUqB;AACxB,mCAAsC;AAA7B,8BAAA,UAAU,CAAA;AAEnB,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC;AACzC,IAAI,CAAC,MAAM,EAAE;IACX,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;CACtD;AAED,MAAM,EAAE,GAAG,IAAI,OAAE,CAAC,MAAM,CAAC,CAAC;AAE1B;;;GAGG;AACI,KAAK,UAAU,GAAG,CAA+B,GAAW;IACjE,OAAO,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC3B,CAAC;AAFD,kBAEC;AAED;;;;GAIG;AACI,KAAK,UAAU,MAAM,CAAC,GAAW,EAAE,KAAmB;IAC3D,OAAO,MAAM,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AACrC,CAAC;AAFD,wBAEC;AAED;;;GAGG;AACI,KAAK,UAAU,MAAM,CAAC,GAAW;IACtC,OAAO,MAAM,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AAC9B,CAAC;AAFD,wBAEC;AAED;;;;;GAKG;AACI,KAAK,UAAU,MAAM,CAC1B,GAAW,EAAE,OAAuC,EAAE,OAAuB;IAE7E,OAAO,MAAM,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAChD,CAAC;AAJD,wBAIC;AAED;;;;GAIG;AACI,KAAK,UAAU,IAAI,CAAC,KAAc;IACvC,OAAO,MAAM,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAFD,oBAEC;AAED;;GAEG;AACI,KAAK,UAAU,IAAI,CAAC,cAA6B;IACtD,OAAO,MAAM,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;AACvC,CAAC;AAFD,oBAEC;AACD,IAAI,CAAC,WAAW,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAErC;;GAEG;AACI,KAAK,UAAU,YAAY,CAA+B,GAAW;IAC1E,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,WAAW,CAAI,GAAG,CAAC,CAAC;IACzC,IAAI,GAAG,KAAK,SAAS,EAAE;QACrB,OAAO;YACL,2EAA2E;YAC3E,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE;YAC/B,KAAK,EAAE,SAAS;SACjB,CAAC;KACH;IACD,OAAO;QACL,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,KAAK,EAAE,GAAG,CAAC,KAAK;KACjB,CAAC;AACJ,CAAC;AAbD,oCAaC;AACD,YAAY,CAAC,WAAW,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC"}
		{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

+26

-21

package.json

		{
		"name": "@binaris/shift-db",
		"version": "0.3.1",
		"files": [
		"dist"
		],
		"description": "",
		"version": "0.4.0-dbnu",
		"description": "(Backend) client for accessing ShiftJS DBs.",
		"main": "dist/index.js",
		"files": "dist/",
		"types": "dist/index.d.ts",
		@@ -13,27 +11,34 @@ "scripts": {
		"lint": "tslint -c ../common/tslint.yml -p .",
		"test": "ava -v dist/test/*.js"
		"test": "ava dist/test/component/*.js"
		},
		"keywords": [
		"binaris",
		"shift",
		"shiftjs",
		"db",
		"client",
		"db-client",
		"shift-db"
		],
		"author": "",
		"license": "MIT",
		"dependencies": {
		"@binaris/shift-interfaces-node-client": "^0.3.0",
		"@types/deep-freeze": "^0.1.1",
		"@types/leveldown": "^4.0.0",
		"@types/levelup": "^3.1.1",
		"async-mutex": "^0.1.3",
		"deep-freeze": "^0.0.1",
		"fast-json-patch": "^2.2.0",
		"leveldown": "^5.1.1",
		"levelup": "^4.1.0",
		"@binaris/shift-interfaces-node-client": "0.4.0-nudb.1",
		"@types/deep-freeze": "^0.1.2",
		"deep-freeze": "0.0.1",
		"ramda": "^0.26.1"
		},
		"devDependencies": {
		"@types/node": "^10.14.9",
		"@types/ramda": "^0.26.18",
		"@binaris/shift-interfaces-koa-server": "0.4.0-nudb.1",
		"@binaris/shift-leveldb-server": "0.0.1-dbnu",
		"@types/koa": "~2.0.49",
		"@types/koa-router": "~7.0.42",
		"@types/node": "^12.7.2",
		"@types/ramda": "^0.26.19",
		"@types/rmfr": "^2.0.0",
		"ava": "^2.2.0",
		"rmfr": "^2.0.0",
		"tslint": "^5.18.0",
		"typescript": "^3.5.3"
		"ava": "^2.3.0",
		"koa": "~2.8.1",
		"koa-router": "~7.4.0",
		"rmfr": "^2.0.0"
		}
		}

-171

CHANGELOG.json

		{
		"name": "@binaris/shift-db",
		"entries": [
		{
		"version": "0.3.1",
		"tag": "@binaris/shift-db_v0.3.1",
		"date": "Mon, 12 Aug 2019 13:45:13 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Update client version"
		}
		]
		}
		},
		{
		"version": "0.3.0",
		"tag": "@binaris/shift-db_v0.3.0",
		"date": "Tue, 06 Aug 2019 12:22:25 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Use exported types from client package"
		}
		],
		"minor": [
		{
		"comment": "Disallow all non-JSONable types at top level of values"
		}
		]
		}
		},
		{
		"version": "0.2.2",
		"tag": "@binaris/shift-db_v0.2.2",
		"date": "Thu, 01 Aug 2019 12:37:42 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Release packages publicly"
		}
		],
		"dependency": [
		{
		"comment": "Updating dependency \"@binaris/shift-interfaces\" from `0.1.1` to `0.1.2`"
		}
		]
		}
		},
		{
		"version": "0.2.1",
		"tag": "@binaris/shift-db_v0.2.1",
		"date": "Mon, 29 Jul 2019 06:11:31 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Rename getVersioned to startPolling"
		},
		{
		"comment": "Change return types of exposed subscription functions"
		},
		{
		"comment": "Fix version comparison"
		}
		],
		"dependency": [
		{
		"comment": "Updating dependency \"@binaris/shift-interfaces\" from `0.1.0` to `0.1.1`"
		}
		]
		}
		},
		{
		"version": "0.2.0",
		"tag": "@binaris/shift-db_v0.2.0",
		"date": "Thu, 18 Jul 2019 12:48:13 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Change db.update API and Serializable type"
		},
		{
		"comment": "Refactor exportable interfaces into shift-interfaces."
		},
		{
		"comment": "Change db.get() return type"
		},
		{
		"comment": "Export getVersioned() and poll()"
		},
		{
		"comment": "Properly export types"
		}
		],
		"minor": [
		{
		"comment": "Implement subscription functions"
		}
		],
		"dependency": [
		{
		"comment": "Updating dependency \"@binaris/shift-interfaces\" from `0.0.1` to `0.1.0`"
		}
		]
		}
		},
		{
		"version": "0.1.2",
		"tag": "@binaris/shift-db_v0.1.2",
		"date": "Wed, 10 Jul 2019 12:29:59 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Implement query language"
		}
		]
		}
		},
		{
		"version": "0.1.1",
		"tag": "@binaris/shift-db_v0.1.1",
		"date": "Tue, 09 Jul 2019 13:02:12 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Downgrade AVA dependency"
		}
		]
		}
		},
		{
		"version": "0.1.0",
		"tag": "@binaris/shift-db_v0.1.0",
		"date": "Tue, 09 Jul 2019 07:46:16 GMT",
		"comments": {
		"minor": [
		{
		"comment": "Accept any JSONable as DB value"
		}
		]
		}
		},
		{
		"version": "0.0.2",
		"tag": "@binaris/shift-db_v0.0.2",
		"date": "Tue, 09 Jul 2019 07:26:14 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Add linting"
		},
		{
		"comment": "Limit distributed files"
		}
		]
		}
		},
		{
		"version": "0.0.1",
		"tag": "@binaris/shift-db_v0.0.1",
		"date": "Thu, 20 Jun 2019 15:03:42 GMT",
		"comments": {
		"patch": [
		{
		"comment": "Initial version"
		}
		]
		}
		}
		]
		}

-89

CHANGELOG.md

		# Change Log - @binaris/shift-db

		This log was last generated on Mon, 12 Aug 2019 13:45:13 GMT and should not be manually modified.

		## 0.3.1
		Mon, 12 Aug 2019 13:45:13 GMT

		### Patches

		- Update client version

		## 0.3.0
		Tue, 06 Aug 2019 12:22:25 GMT

		### Minor changes

		- Disallow all non-JSONable types at top level of values

		### Patches

		- Use exported types from client package

		## 0.2.2
		Thu, 01 Aug 2019 12:37:42 GMT

		### Patches

		- Release packages publicly

		## 0.2.1
		Mon, 29 Jul 2019 06:11:31 GMT

		### Patches

		- Rename getVersioned to startPolling
		- Change return types of exposed subscription functions
		- Fix version comparison

		## 0.2.0
		Thu, 18 Jul 2019 12:48:13 GMT

		### Minor changes

		- Implement subscription functions

		### Patches

		- Change db.update API and Serializable type
		- Refactor exportable interfaces into shift-interfaces.
		- Change db.get() return type
		- Export getVersioned() and poll()
		- Properly export types

		## 0.1.2
		Wed, 10 Jul 2019 12:29:59 GMT

		### Patches

		- Implement query language

		## 0.1.1
		Tue, 09 Jul 2019 13:02:12 GMT

		### Patches

		- Downgrade AVA dependency

		## 0.1.0
		Tue, 09 Jul 2019 07:46:16 GMT

		### Minor changes

		- Accept any JSONable as DB value

		## 0.0.2
		Tue, 09 Jul 2019 07:26:14 GMT

		### Patches

		- Add linting
		- Limit distributed files

		## 0.0.1
		Thu, 20 Jun 2019 15:03:42 GMT

		### Patches

		- Initial version

-87

dist/db.d.ts

		/// <reference types="node" />
		import { EventEmitter } from 'events';
		import { DeepReadonly } from 'deep-freeze';
		import { LevelUp } from 'levelup';
		import { Mutex } from 'async-mutex';
		import { UpdateOptions, Version, Patch } from '@binaris/shift-interfaces-node-client/interfaces';
		import * as Q from './query';
		export { Q, DeepReadonly, UpdateOptions, };
		export interface Versioned<T> {
		version: Version;
		value: T;
		}
		export declare type KeyedPatches = Array<[string, Patch[]]>;
		export declare type Serializable = {} \| null;
		export declare function incrVersion({ major, minor }: Version, amount?: number): Version;
		export declare function decrVersion(version: Version, amount?: number): Version;
		export declare function isGreaterVersion(a: Version, b: Version): boolean;
		export declare type KeyedVersions = Array<[string, Version]>;
		interface StoredDocument<T> extends Versioned<T> {
		/**
		* Stores changes made to the document, meant to be used internally by poll().
		*/
		readonly patches: ReadonlyArray<Patch>;
		readonly updatedAt: number;
		}
		/**
		* The result of a remove operation on a document - meant to be periodically pruned.
		*/
		declare type Tombstone = StoredDocument<undefined>;
		export interface PollOptions {
		readBlockTimeMs: number;
		}
		export interface Document {
		key: string;
		value: Serializable;
		}
		export declare class DB extends EventEmitter {
		protected readonly dbPath: string;
		protected readonly writeLock: Mutex;
		protected readonly db: LevelUp;
		constructor(dbPath: string);
		protected put(key: string, prev: StoredDocument<any> \| undefined, value: any, options?: UpdateOptions): Promise<void>;
		/**
		* Gets a single document.
		* @return - value or undefined if key doesn’t exist.
		*/
		get<T extends Serializable = any>(key: string): Promise<T \| undefined>;
		/**
		* Gets a single document with its version.
		* @return - { version, value } or undefined if key doesn’t exist.
		*/
		getWithMeta<T extends Serializable = any>(key: string): Promise<StoredDocument<T> \| Tombstone \| undefined>;
		/**
		* Creates a document for given key.
		* @param value - Cannot be undefined, must be an object
		* @return - true if document was created, false if key already exists.
		*/
		create(key: string, value: Serializable): Promise<boolean>;
		/**
		* Removes a single document.
		* @return - true if document was deleted, false if key doesn’t exist.
		*/
		remove(key: string): Promise<boolean>;
		/**
		* Updates a single document.
		* @param updater - Function that gets the previous value and returns the next value to update the DB with.
		* Cannot return undefined, receives undefined in case key doesn’t already exist in the DB.
		* @return - The new value returned from updater
		*/
		update<T extends Serializable = any>(key: string, updater: (state?: DeepReadonly<T>) => T, options?: UpdateOptions): Promise<DeepReadonly<T>>;
		/**
		* Polls on updates to specified keys since specified versions.
		* @see KeyedVersions
		* @see KeyedPatches
		*/
		poll(keysToVersions: KeyedVersions, opts?: Partial<PollOptions>): Promise<KeyedPatches>;
		/**
		* Find documents matching query.
		* @param query - a query constructed with Q methods.
		* @return - an array of documents
		*/
		find(query: Q.Query): Promise<Document[]>;
		}
		export declare function buildComparator({ path: p, direction }: Q.Order): (a: any, b: any) => number;
		export declare function wrappedMatch(doc: Document, filter: Q.Filter): boolean;
		export declare function match(doc: Document, filter: Q.Filter): boolean;
		//# sourceMappingURL=db.d.ts.map

-1

dist/db.d.ts.map

{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"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"}

-282

dist/db.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		var __importStar = (this && this.__importStar) \|\| function (mod) {
		if (mod && mod.__esModule) return mod;
		var result = {};
		if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
		result["default"] = mod;
		return result;
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const events_1 = require("events");
		const ramda_1 = require("ramda");
		const deep_freeze_1 = __importDefault(require("deep-freeze"));
		const fast_json_patch_1 = require("fast-json-patch");
		const levelup_1 = __importDefault(require("levelup"));
		const leveldown_1 = __importDefault(require("leveldown"));
		const async_mutex_1 = require("async-mutex");
		const errors_1 = require("./errors");
		const Q = __importStar(require("./query"));
		exports.Q = Q;
		const utils_1 = require("./utils");
		const NUM_PATCHES_TO_KEEP = 20;
		const DEFAULT_READ_BLOCK_TIME_MS = 50000;
		function incrVersion({ major, minor }, amount = 1) {
		return { major, minor: minor + amount };
		}
		exports.incrVersion = incrVersion;
		function decrVersion(version, amount = 1) {
		return incrVersion(version, -amount);
		}
		exports.decrVersion = decrVersion;
		function isGreaterVersion(a, b) {
		return a.major > b.major \|\| a.major === b.major && a.minor > b.minor;
		}
		exports.isGreaterVersion = isGreaterVersion;
		// bigint not currently allowed.
		const allowedTypes = new Set(['object', 'boolean', 'number', 'string']);
		function checkValue(value) {
		if (!allowedTypes.has(typeof value)) {
		throw new TypeError(`Non-JSONable value of type ${typeof value} at top level`);
		}
		}
		class DB extends events_1.EventEmitter {
		constructor(dbPath) {
		super();
		this.dbPath = dbPath;
		this.writeLock = new async_mutex_1.Mutex();
		this.db = new levelup_1.default(new leveldown_1.default(dbPath));
		}
		async put(key, prev, value, options) {
		const prevValue = prev === undefined ? undefined : prev.value;
		const version = prev === undefined \|\| prev.value === undefined ?
		{ major: utils_1.hrnano(), minor: 1 } : incrVersion(prev.version);
		const patches = prev ? prev.patches : [];
		const ops = fast_json_patch_1.compare({ root: prevValue }, { root: value });
		if (ops.length > 0) {
		const patch = Object.assign({ version, ops }, options);
		await this.db.put(key, JSON.stringify({
		version,
		value,
		patches: patches.slice(-NUM_PATCHES_TO_KEEP).concat(patch),
		updatedAt: utils_1.hrnano(),
		}));
		this.emit('patch', key, patch);
		}
		}
		/**
		* Gets a single document.
		* @return - value or undefined if key doesn’t exist.
		*/
		async get(key) {
		const versioned = await this.getWithMeta(key);
		if (versioned === undefined) {
		return undefined;
		}
		return versioned.value;
		}
		/**
		* Gets a single document with its version.
		* @return - { version, value } or undefined if key doesn’t exist.
		*/
		async getWithMeta(key) {
		try {
		const val = await this.db.get(key);
		return JSON.parse(val.toString());
		}
		catch (err) {
		if (err.name === 'NotFoundError') {
		return undefined;
		}
		throw err;
		}
		}
		/**
		* Creates a document for given key.
		* @param value - Cannot be undefined, must be an object
		* @return - true if document was created, false if key already exists.
		*/
		async create(key, value) {
		checkValue(value);
		return await this.writeLock.runExclusive(async () => {
		const prev = await this.getWithMeta(key);
		if (prev !== undefined && prev.value !== undefined) {
		return false;
		}
		await this.put(key, prev, value);
		return true;
		});
		}
		/**
		* Removes a single document.
		* @return - true if document was deleted, false if key doesn’t exist.
		*/
		async remove(key) {
		return await this.writeLock.runExclusive(async () => {
		const prev = await this.getWithMeta(key);
		if (prev === undefined \|\| prev.value === undefined) {
		return false;
		}
		// TODO: Schedule periodic DB vacuum and delete old tombstones
		await this.put(key, prev, undefined);
		return true;
		});
		}
		/**
		* Updates a single document.
		* @param updater - Function that gets the previous value and returns the next value to update the DB with.
		* Cannot return undefined, receives undefined in case key doesn’t already exist in the DB.
		* @return - The new value returned from updater
		*/
		async update(key, updater, options) {
		return await this.writeLock.runExclusive(async () => {
		const prev = await this.getWithMeta(key);
		const frozen = deep_freeze_1.default({ value: prev && prev.value });
		// We could have made updater return DeepReadonly<T> but that would make writing updaters very hard.
		// We decided to work around the type system to prevent the case that a user tries to modify the return
		// value and gets a TypeError.
		const nextValue = updater(frozen.value);
		checkValue(nextValue);
		await this.put(key, prev, nextValue, options);
		return nextValue;
		});
		}
		/**
		* Polls on updates to specified keys since specified versions.
		* @see KeyedVersions
		* @see KeyedPatches
		*/
		async poll(keysToVersions, opts = {}) {
		const keysToVersionsMap = new Map(keysToVersions);
		const { promise, resolve } = utils_1.deferred();
		// Make sure we don't miss any live updates in case the initial scan (below) comes back empty.
		const patchHandler = (key, patch) => {
		const subscribedVersion = keysToVersionsMap.get(key);
		if (subscribedVersion !== undefined && isGreaterVersion(patch.version, subscribedVersion)) {
		resolve([[key, [patch]]]);
		}
		};
		this.on('patch', patchHandler);
		try {
		// Scan the DB for matching patches
		const keyedPatchesOrUndef = await Promise.all(keysToVersions.map(async ([key, version]) => {
		const doc = await this.getWithMeta(key);
		if (doc === undefined) {
		return undefined;
		}
		const patches = doc.patches.filter((patch) => isGreaterVersion(patch.version, version));
		if (patches.length === 0) {
		return undefined;
		}
		return ramda_1.pair(key, patches);
		}));
		const keyedPatches = keyedPatchesOrUndef.filter((patch) => patch !== undefined);
		if (keyedPatches.length > 0) {
		return keyedPatches;
		}
		try {
		return await utils_1.withTimeout(promise, opts.readBlockTimeMs \|\| DEFAULT_READ_BLOCK_TIME_MS);
		}
		catch (err) {
		if (err.name === 'TimeoutError') {
		return [];
		}
		throw err;
		}
		}
		finally {
		this.off('patch', patchHandler);
		}
		}
		/**
		* Find documents matching query.
		* @param query - a query constructed with Q methods.
		* @return - an array of documents
		*/
		async find(query) {
		const { filter, limit, skip, orderBy } = query.getParts();
		const results = [];
		await new Promise((resolve, reject) => {
		const it = this.db.iterator({
		keyAsBuffer: false,
		valueAsBuffer: false,
		});
		const next = (err, key, rawValue) => {
		if (err) {
		return reject(err);
		}
		if (!key) {
		// Iteration complete
		return it.end(resolve);
		}
		const { value } = JSON.parse(rawValue);
		if (value !== undefined /* Not a tombstone */ && wrappedMatch({ key, value }, filter)) {
		results.push({ key, value });
		}
		return it.next(next);
		};
		it.next(next);
		});
		const sortedResults = orderBy ? ramda_1.sortWith(orderBy.map(buildComparator), results) : results;
		return sortedResults.slice(skip, limit === undefined ? undefined : (skip \|\| 0) + limit);
		}
		}
		exports.DB = DB;
		function buildComparator({ path: p, direction }) {
		return direction === Q.ASC ? ramda_1.ascend(ramda_1.path(p)) : ramda_1.descend(ramda_1.path(p));
		}
		exports.buildComparator = buildComparator;
		function wrappedMatch(doc, filter) {
		const isMatch = match(doc, filter);
		if (isMatch === undefined) {
		throw new errors_1.ValueError(`Got an unsupported filter operator: ${filter.operator}`);
		}
		return isMatch;
		}
		exports.wrappedMatch = wrappedMatch;
		function match(doc, filter) {
		switch (filter.operator) {
		case 'and':
		return filter.filters.every((f) => wrappedMatch(doc, f));
		case 'or':
		return filter.filters.some((f) => wrappedMatch(doc, f));
		case 'not':
		return !wrappedMatch(doc, filter.filter);
		}
		const value = ramda_1.path(filter.path, doc);
		switch (filter.operator) {
		case 'eq':
		return value === filter.value;
		case 'ne':
		return value !== filter.value;
		case 'gt':
		return typeof value === typeof filter.value && value > filter.value;
		case 'gte':
		return typeof value === typeof filter.value && value >= filter.value;
		case 'lt':
		return typeof value === typeof filter.value && value < filter.value;
		case 'lte':
		return typeof value === typeof filter.value && value <= filter.value;
		case 'exists':
		return value !== undefined;
		case 'isNull':
		return value === null;
		case 'matches':
		if (typeof value !== 'string') {
		return false;
		}
		const regexp = new RegExp(filter.pattern, filter.caseInsensitive ? 'i' : undefined);
		return regexp.test(value);
		case 'startsWith':
		if (typeof value !== 'string') {
		return false;
		}
		return value.startsWith(filter.value);
		// We don't add a default case here to let typescript catch when new operators are added and not implemented here.
		// (see wrappedMatch)
		}
		}
		exports.match = match;
		//# sourceMappingURL=db.js.map

-1

dist/db.js.map

-7

dist/errors.d.ts

		export declare class ValueError extends Error {
		readonly name = "ValueError";
		}
		export declare class IllegalArgumentError extends Error {
		readonly name = "IllegalArgumentError";
		}
		//# sourceMappingURL=errors.d.ts.map

-1

dist/errors.d.ts.map

{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,IAAI,gBAAgB;CACrC;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,SAAgB,IAAI,0BAA0B;CAC/C"}

-17

dist/errors.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		class ValueError extends Error {
		constructor() {
		super(...arguments);
		this.name = 'ValueError';
		}
		}
		exports.ValueError = ValueError;
		class IllegalArgumentError extends Error {
		constructor() {
		super(...arguments);
		this.name = 'IllegalArgumentError';
		}
		}
		exports.IllegalArgumentError = IllegalArgumentError;
		//# sourceMappingURL=errors.js.map

-1

dist/errors.js.map

{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;AAAA,MAAa,UAAW,SAAQ,KAAK;IAArC;;QACkB,SAAI,GAAG,YAAY,CAAC;IACtC,CAAC;CAAA;AAFD,gCAEC;AAED,MAAa,oBAAqB,SAAQ,KAAK;IAA/C;;QACkB,SAAI,GAAG,sBAAsB,CAAC;IAChD,CAAC;CAAA;AAFD,oDAEC"}

-179

dist/query.d.ts

		import * as dbi from '@binaris/shift-interfaces-node-client/interfaces';
		declare type Key = string \| number;
		declare const filterSymbol: unique symbol;
		export declare type Marked<T extends {}> = T & {
		[filterSymbol]: true;
		};
		export declare type EqFilter = Marked<dbi.EqFilter>;
		export declare type NeFilter = Marked<dbi.NeFilter>;
		export declare type GtFilter = Marked<dbi.GtFilter>;
		export declare type GteFilter = Marked<dbi.GteFilter>;
		export declare type LtFilter = Marked<dbi.LtFilter>;
		export declare type LteFilter = Marked<dbi.LteFilter>;
		export declare type ExistsFilter = Marked<dbi.ExistsFilter>;
		export declare type IsNullFilter = Marked<dbi.IsNullFilter>;
		export declare type MatchesFilter = Marked<dbi.MatchesFilter>;
		export declare type StartsWithFilter = Marked<dbi.StartsWithFilter>;
		export declare type Equatable = dbi.Equatable;
		export declare type Comparable = dbi.Comparable;
		export declare type Direction = dbi.Direction;
		export declare type Order = dbi.Order;
		export declare const ASC = dbi.Direction.ASC;
		export declare const DESC = dbi.Direction.DESC;
		interface AndFilter extends Marked<dbi.AndFilter> {
		readonly filters: Filter[];
		}
		interface OrFilter extends Marked<dbi.OrFilter> {
		readonly filters: Filter[];
		}
		interface NotFilter extends Marked<dbi.NotFilter> {
		readonly filter: Filter;
		}
		export declare type Filter = EqFilter \| NeFilter \| GtFilter \| GteFilter \| LtFilter \| LteFilter \| ExistsFilter \| IsNullFilter \| MatchesFilter \| StartsWithFilter \| AndFilter \| OrFilter \| NotFilter;
		declare class Path {
		protected readonly parts: string[];
		constructor(parts: string[]);
		static proxied(parts: string[]): PathProxy;
		/**
		* Returns a subpath at given key.
		* @param key - object key or array index
		* @return - subpath of document
		*/
		field(k: Key): PathProxy;
		/**
		* Returns a subpath at given key.
		* Has a template parameter for improved type safety when using typescript.
		* @param key - object key or array index
		* @return - subpath of document
		*/
		typedField<T>(k: Key): Doc<T>;
		/**
		* Equals
		* @param x - value for comparison
		* @return - a filter
		*/
		eq(x: Equatable): EqFilter;
		/**
		* Not equals
		* @param x - value for comparison
		* @return - a filter
		*/
		ne(x: Equatable): NeFilter;
		/**
		* Greater than
		* @param x - value for comparison
		* @return - a filter
		*/
		gt(x: Comparable): GtFilter;
		/**
		* Greater than or equals
		* @param x - value for comparison
		* @return - a filter
		*/
		gte(x: Comparable): GteFilter;
		/**
		* Less than
		* @param x - value for comparison
		* @return - a filter
		*/
		lt(x: Comparable): LtFilter;
		/**
		* Less than or equals
		* @param x - value for comparison
		* @return - a filter
		*/
		lte(x: Comparable): LteFilter;
		/**
		* Does path exist?
		* @return - a filter
		*/
		exists(): ExistsFilter;
		/**
		* Is value at path null?
		* @return - a filter
		*/
		isNull(): IsNullFilter;
		/**
		* String matches pattern.
		* @param pattern regular expression
		* @param caseInsensitive should the check be case insensitive?
		* @return - a filter
		*/
		matches(pattern: string, caseInsensitive?: boolean): MatchesFilter;
		/**
		* String matches pattern.
		* @param pattern - regular expression, if the RegExp object has the 'i' flag, perform a case insensitive match.
		* @return - a filter
		*/
		matches(pattern: RegExp): MatchesFilter;
		/**
		* String starts with prefix
		* @return - a filter
		*/
		startsWith(prefix: string): StartsWithFilter;
		/**
		* Casts to a specific doc type. Use for typed paths with typescript.
		* @return - a filter
		*/
		as<T>(): Doc<T>;
		}
		declare type PathProxy = Path & Record<Key, Path>;
		interface CastablePath {
		as<T>(): Doc<T>;
		}
		interface EquatablePath<T extends Equatable> extends CastablePath {
		eq(x: T): EqFilter;
		ne(x: T): NeFilter;
		}
		interface ComparablePath<T extends Comparable> extends EquatablePath<T> {
		gt(x: T): GtFilter;
		gte(x: T): GteFilter;
		lt(x: T): LtFilter;
		lte(x: T): LteFilter;
		}
		interface StringPath extends ComparablePath<string> {
		matches(pattern: string, caseInsensitive?: boolean): MatchesFilter;
		matches(pattern: RegExp): MatchesFilter;
		startsWith(prefix: string): StartsWithFilter;
		}
		declare type NumberPath = ComparablePath<number>;
		declare type DatePath = ComparablePath<Date>;
		declare type BooleanPath = EquatablePath<boolean>;
		interface NullPath extends CastablePath {
		isNull(): IsNullFilter;
		}
		interface MaybePath extends CastablePath {
		exists(): Filter;
		}
		declare type Doc<T> = T extends Record<string, unknown> ? Required<{
		[P in keyof T]: Doc<T[P]> & MaybePath;
		}> : T extends Array<infer U> ? {
		[idx: number]: Doc<U> & MaybePath;
		} : T extends null ? NullPath : T extends number ? NumberPath : T extends string ? StringPath : T extends boolean ? BooleanPath : T extends Date ? DatePath : never;
		export declare function typedValue<T>(): Doc<T>;
		export declare const key: StringPath;
		export declare const value: PathProxy;
		declare type NonEmptyArray<T> = [T, ...T[]];
		export declare function all(...filters: NonEmptyArray<Filter>): AndFilter;
		export declare function any(...filters: NonEmptyArray<Filter>): OrFilter;
		export declare function not(f: Filter): NotFilter;
		export interface QueryData extends dbi.Query {
		filter: Filter;
		}
		export declare class Query {
		protected readonly _filter: Filter;
		protected readonly _limit?: number \| undefined;
		protected readonly _skip?: number \| undefined;
		protected readonly _orderBy?: dbi.Order[] \| undefined;
		protected constructor(_filter: Filter, _limit?: number \| undefined, _skip?: number \| undefined, _orderBy?: dbi.Order[] \| undefined);
		filter(f: Filter): Query;
		limit(l: number): Query;
		skip(s: number): Query;
		orderBy(path: Path \| Doc<any>, order?: Direction): Query;
		static fromFilter(f: Filter): Query;
		toJSON(): QueryData;
		getParts(): QueryData;
		}
		export declare const filter: typeof Query.fromFilter;
		export {};
		//# sourceMappingURL=query.d.ts.map

-1

dist/query.d.ts.map

-283

dist/query.js

		"use strict";
		var __importStar = (this && this.__importStar) \|\| function (mod) {
		if (mod && mod.__esModule) return mod;
		var result = {};
		if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
		result["default"] = mod;
		return result;
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const ramda_1 = require("ramda");
		const errors_1 = require("./errors");
		const dbi = __importStar(require("@binaris/shift-interfaces-node-client/interfaces"));
		const filterSymbol = Symbol('shiftjs/filter');
		exports.ASC = dbi.Direction.ASC;
		exports.DESC = dbi.Direction.DESC;
		const proxyHandler = {
		get(obj, prop) {
		// Known properties such as `field` and `eq` are used as defined, unknown properties are used as fields.
		return prop in obj ? obj[prop] : obj.field(prop);
		},
		};
		class Path {
		constructor(parts) {
		this.parts = parts;
		}
		static proxied(parts) {
		return new Proxy(new this(parts), proxyHandler);
		}
		/**
		* Returns a subpath at given key.
		* @param key - object key or array index
		* @return - subpath of document
		*/
		field(k) {
		// When using proxy, paths will be converted to string, field() replicates this behavior
		return Path.proxied([...this.parts, k.toString()]);
		}
		/**
		* Returns a subpath at given key.
		* Has a template parameter for improved type safety when using typescript.
		* @param key - object key or array index
		* @return - subpath of document
		*/
		typedField(k) {
		return this.field(k);
		}
		/**
		* Equals
		* @param x - value for comparison
		* @return - a filter
		*/
		eq(x) {
		return {
		[filterSymbol]: true,
		operator: 'eq',
		path: this.parts,
		value: x,
		};
		}
		/**
		* Not equals
		* @param x - value for comparison
		* @return - a filter
		*/
		ne(x) {
		return {
		[filterSymbol]: true,
		operator: 'ne',
		path: this.parts,
		value: x,
		};
		}
		/**
		* Greater than
		* @param x - value for comparison
		* @return - a filter
		*/
		gt(x) {
		return {
		[filterSymbol]: true,
		operator: 'gt',
		path: this.parts,
		value: x,
		};
		}
		/**
		* Greater than or equals
		* @param x - value for comparison
		* @return - a filter
		*/
		gte(x) {
		return {
		[filterSymbol]: true,
		operator: 'gte',
		path: this.parts,
		value: x,
		};
		}
		/**
		* Less than
		* @param x - value for comparison
		* @return - a filter
		*/
		lt(x) {
		return {
		[filterSymbol]: true,
		operator: 'lt',
		path: this.parts,
		value: x,
		};
		}
		/**
		* Less than or equals
		* @param x - value for comparison
		* @return - a filter
		*/
		lte(x) {
		return {
		[filterSymbol]: true,
		operator: 'lte',
		path: this.parts,
		value: x,
		};
		}
		/**
		* Does path exist?
		* @return - a filter
		*/
		exists() {
		return {
		[filterSymbol]: true,
		operator: 'exists',
		path: this.parts,
		};
		}
		/**
		* Is value at path null?
		* @return - a filter
		*/
		isNull() {
		return {
		[filterSymbol]: true,
		operator: 'isNull',
		path: this.parts,
		};
		}
		matches(pattern, caseInsensitive = false) {
		if (typeof pattern === 'string') {
		return {
		[filterSymbol]: true,
		operator: 'matches',
		path: this.parts,
		pattern,
		caseInsensitive,
		};
		}
		else if (pattern instanceof RegExp) {
		if (/[^i]/.test(pattern.flags)) {
		throw new TypeError('Only /i RegExp flag supported');
		}
		return {
		[filterSymbol]: true,
		operator: 'matches',
		path: this.parts,
		pattern: pattern.source,
		caseInsensitive: pattern.flags.includes('i'),
		};
		}
		throw new TypeError('Expected pattern to be a RegExp or string');
		}
		/**
		* String starts with prefix
		* @return - a filter
		*/
		startsWith(prefix) {
		return {
		[filterSymbol]: true,
		operator: 'startsWith',
		path: this.parts,
		value: prefix,
		};
		}
		/**
		* Casts to a specific doc type. Use for typed paths with typescript.
		* @return - a filter
		*/
		as() {
		return Path.proxied(this.parts);
		}
		}
		function typedValue() {
		return Path.proxied(['value']);
		}
		exports.typedValue = typedValue;
		exports.key = Path.proxied(['key']);
		exports.value = Path.proxied(['value']);
		function checkFilters(...filters) {
		if (filters.length === 0) {
		throw new errors_1.IllegalArgumentError('Expected at least 1 filter');
		}
		for (const f of filters) {
		if (!f[filterSymbol]) {
		throw new TypeError('Given filter is invalid');
		}
		}
		}
		function all(...filters) {
		checkFilters(...filters);
		return {
		[filterSymbol]: true,
		operator: 'and',
		filters,
		};
		}
		exports.all = all;
		function any(...filters) {
		checkFilters(...filters);
		return {
		[filterSymbol]: true,
		operator: 'or',
		filters,
		};
		}
		exports.any = any;
		function not(f) {
		checkFilters(f);
		return {
		[filterSymbol]: true,
		operator: 'not',
		filter: f,
		};
		}
		exports.not = not;
		class Query {
		constructor(_filter, _limit, _skip, _orderBy) {
		this._filter = _filter;
		this._limit = _limit;
		this._skip = _skip;
		this._orderBy = _orderBy;
		}
		filter(f) {
		return new Query(all(this._filter, f), this._limit, this._skip, this._orderBy);
		}
		limit(l) {
		if (l < 1) {
		throw new errors_1.IllegalArgumentError(`Given limit (${l}) is less than 1`);
		}
		if (this._limit !== undefined && l > this._limit) {
		throw new errors_1.IllegalArgumentError(`Given limit (${l}) is greater than current limit (${this._limit})`);
		}
		return new Query(this._filter, l, this._skip, this._orderBy);
		}
		skip(s) {
		return new Query(this._filter, this._limit, s, this._orderBy);
		}
		orderBy(path, order = exports.ASC) {
		const { parts } = path;
		for (const { path: p } of (this._orderBy \|\| [])) {
		if (ramda_1.equals(p, parts)) {
		throw new errors_1.IllegalArgumentError(`Query already ordered by path: ${p}`);
		}
		}
		return new Query(this._filter, this._limit, this._skip, [...(this._orderBy \|\| []), { path: parts, direction: order }]);
		}
		static fromFilter(f) {
		checkFilters(f);
		return new this(f);
		}
		toJSON() {
		return this.getParts();
		}
		getParts() {
		return {
		filter: this._filter,
		limit: this._limit,
		skip: this._skip,
		orderBy: this._orderBy,
		};
		}
		}
		exports.Query = Query;
		exports.filter = Query.fromFilter.bind(Query);
		//# sourceMappingURL=query.js.map

-1

dist/query.js.map

-2

dist/test/db.find.spec.d.ts

		export {};
		//# sourceMappingURL=db.find.spec.d.ts.map

-1

dist/test/db.find.spec.d.ts.map

{"version":3,"file":"db.find.spec.d.ts","sourceRoot":"","sources":["../../src/test/db.find.spec.ts"],"names":[],"mappings":""}

-81

dist/test/db.find.spec.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const ava_1 = __importDefault(require("ava"));
		const path_1 = __importDefault(require("path"));
		const util_1 = require("util");
		const os_1 = require("os");
		const fs_1 = require("fs");
		const rmfr_1 = __importDefault(require("rmfr"));
		const db_1 = require("../db");
		const test = ava_1.default;
		test.beforeEach(async (t) => {
		const dbDir = await util_1.promisify(fs_1.mkdtemp)(path_1.default.join(os_1.tmpdir(), 'test-state-'), 'utf8');
		t.context = {
		dbDir,
		db: new db_1.DB(`${dbDir}/root.db`),
		};
		});
		test.afterEach(async (t) => {
		await rmfr_1.default(t.context.dbDir);
		});
		test('DB.find returns an empty list when no documents', async (t) => {
		const { db } = t.context;
		t.deepEqual(await db.find(db_1.Q.filter(db_1.Q.key.eq('abc'))), []);
		});
		test('DB.find returns an list of documents', async (t) => {
		const { db } = t.context;
		await db.create('abc', { a: 1 });
		t.deepEqual(await db.find(db_1.Q.filter(db_1.Q.key.eq('abc'))), [{ key: 'abc', value: { a: 1 } }]);
		});
		test('DB.find returns all matching documents', async (t) => {
		const { db } = t.context;
		await db.create('a', { a: 1 });
		await db.create('b', { a: 2 });
		await db.create('c', { a: 3 });
		t.deepEqual(await db.find(db_1.Q.filter(db_1.Q.value.a.gt(1))), [
		{ key: 'b', value: { a: 2 } },
		{ key: 'c', value: { a: 3 } },
		]);
		});
		test('DB.find applies limit', async (t) => {
		const { db } = t.context;
		await db.create('a', { a: 1 });
		await db.create('b', { a: 2 });
		await db.create('c', { a: 3 });
		t.deepEqual(await db.find(db_1.Q.filter(db_1.Q.value.a.gt(0)).limit(2)), [
		{ key: 'a', value: { a: 1 } },
		{ key: 'b', value: { a: 2 } },
		]);
		});
		test('DB.find applies skip', async (t) => {
		const { db } = t.context;
		await db.create('a', { a: 1 });
		await db.create('b', { a: 2 });
		await db.create('c', { a: 3 });
		t.deepEqual(await db.find(db_1.Q.filter(db_1.Q.value.a.gt(0)).skip(1)), [
		{ key: 'b', value: { a: 2 } },
		{ key: 'c', value: { a: 3 } },
		]);
		});
		test('DB.find applies orderBy', async (t) => {
		const { db } = t.context;
		await db.create('a', { a: 1, b: 6 });
		await db.create('b', { a: 2, b: 3 });
		await db.create('c', { a: 3, b: 7 });
		t.deepEqual(await db.find(db_1.Q.filter(db_1.Q.value.a.gt(0))
		.skip(1)
		.limit(1)
		.orderBy(db_1.Q.value.b)), [
		{ key: 'a', value: { a: 1, b: 6 } },
		]);
		});
		test('DB.find ignores tombstones', async (t) => {
		const { db } = t.context;
		await db.create('a', { a: 1, b: 6 });
		await db.remove('a');
		t.deepEqual(await db.find(db_1.Q.filter(db_1.Q.key.eq('a'))), []);
		});
		//# sourceMappingURL=db.find.spec.js.map

-1

dist/test/db.find.spec.js.map

-2

dist/test/db.match.spec.d.ts

		export {};
		//# sourceMappingURL=db.match.spec.d.ts.map

-1

dist/test/db.match.spec.d.ts.map

{"version":3,"file":"db.match.spec.d.ts","sourceRoot":"","sources":["../../src/test/db.match.spec.ts"],"names":[],"mappings":""}

-89

dist/test/db.match.spec.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const ava_1 = __importDefault(require("ava"));
		const db_1 = require("../db");
		ava_1.default('eq checks for strict equality', (t) => {
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.eq(3)));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.eq(2)));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.eq('3')));
		});
		ava_1.default('ne checks for strict equality', (t) => {
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.ne(3)));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.ne(2)));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.ne('3')));
		});
		ava_1.default('gt checks for same type', (t) => {
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.gt(2)));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.gt('2')));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.gt('ab')));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.gt(2)));
		});
		ava_1.default('lt checks for same type', (t) => {
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.lt(4)));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.lt('4')));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.lt('abd')));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.lt(4)));
		});
		ava_1.default('gte checks for same type', (t) => {
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.gte(2)));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.gte(3)));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.gte('2')));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.gte('3')));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.gte('ab')));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.gte('abc')));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.gte(2)));
		});
		ava_1.default('lte checks for same type', (t) => {
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.lte(4)));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.lte(3)));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.lte('4')));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.value.lte('3')));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.lte('abd')));
		t.true(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.lte('abc')));
		t.false(db_1.match({ key: 'abc', value: 3 }, db_1.Q.key.lte(4)));
		});
		ava_1.default('exists checks for undefined', (t) => {
		t.true(db_1.match({ key: 'abc', value: null }, db_1.Q.value.exists()));
		t.true(db_1.match({ key: 'abc', value: 0 }, db_1.Q.value.exists()));
		t.true(db_1.match({ key: 'abc', value: 'a' }, db_1.Q.value.exists()));
		t.false(db_1.match({ key: 'abc', value: {} }, db_1.Q.value.a.exists()));
		});
		ava_1.default('isNull checks for null', (t) => {
		t.true(db_1.match({ key: 'abc', value: null }, db_1.Q.value.isNull()));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.value.isNull()));
		t.false(db_1.match({ key: 'abc', value: 'a' }, db_1.Q.value.isNull()));
		t.false(db_1.match({ key: 'abc', value: {} }, db_1.Q.value.a.isNull()));
		});
		ava_1.default('matches matches string', (t) => {
		t.false(db_1.match({ key: 'abc', value: null }, db_1.Q.value.matches(/abc/i)));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.value.matches(/abc/i)));
		t.true(db_1.match({ key: 'abc', value: 'abc' }, db_1.Q.value.matches(/abc/i)));
		t.true(db_1.match({ key: 'abc', value: 'ABC' }, db_1.Q.value.matches(/abc/i)));
		t.false(db_1.match({ key: 'abc', value: 'ABC' }, db_1.Q.value.matches(/abc/)));
		});
		ava_1.default('startsWith matches string', (t) => {
		t.false(db_1.match({ key: 'abc', value: null }, db_1.Q.value.startsWith('ab')));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.value.startsWith('ab')));
		t.true(db_1.match({ key: 'abc', value: 'abc' }, db_1.Q.value.startsWith('ab')));
		t.false(db_1.match({ key: 'abc', value: 'ABC' }, db_1.Q.value.startsWith('ab')));
		});
		ava_1.default('all applies all filters', (t) => {
		t.true(db_1.match({ key: 'abc', value: 0 }, db_1.Q.all(db_1.Q.key.startsWith('ab'), db_1.Q.value.eq(0))));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.all(db_1.Q.key.startsWith('ab'), db_1.Q.value.eq(1))));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.all(db_1.Q.key.eq('ab'), db_1.Q.value.eq(0))));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.all(db_1.Q.key.eq('ab'), db_1.Q.value.eq(1))));
		});
		ava_1.default('any applies all filters', (t) => {
		t.true(db_1.match({ key: 'abc', value: 0 }, db_1.Q.any(db_1.Q.key.startsWith('ab'), db_1.Q.value.eq(0))));
		t.true(db_1.match({ key: 'abc', value: 0 }, db_1.Q.any(db_1.Q.key.startsWith('ab'), db_1.Q.value.eq(1))));
		t.true(db_1.match({ key: 'abc', value: 0 }, db_1.Q.any(db_1.Q.key.eq('ab'), db_1.Q.value.eq(0))));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.any(db_1.Q.key.eq('ab'), db_1.Q.value.eq(1))));
		});
		ava_1.default('not negates a filter', (t) => {
		t.true(db_1.match({ key: 'abc', value: 0 }, db_1.Q.not(db_1.Q.key.eq('ab'))));
		t.false(db_1.match({ key: 'abc', value: 0 }, db_1.Q.not(db_1.Q.key.startsWith('ab'))));
		});
		//# sourceMappingURL=db.match.spec.js.map

-1

dist/test/db.match.spec.js.map

-2

dist/test/db.spec.d.ts

		export {};
		//# sourceMappingURL=db.spec.d.ts.map

-1

dist/test/db.spec.d.ts.map

{"version":3,"file":"db.spec.d.ts","sourceRoot":"","sources":["../../src/test/db.spec.ts"],"names":[],"mappings":""}

-319

dist/test/db.spec.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const ava_1 = __importDefault(require("ava"));
		const ramda_1 = require("ramda");
		const path_1 = __importDefault(require("path"));
		const util_1 = require("util");
		const os_1 = require("os");
		const fs_1 = require("fs");
		const rmfr_1 = __importDefault(require("rmfr"));
		const db_1 = require("../db");
		const utils_1 = require("../utils");
		const test = ava_1.default;
		test.beforeEach(async (t) => {
		const dbDir = await util_1.promisify(fs_1.mkdtemp)(path_1.default.join(os_1.tmpdir(), 'test-state-'), 'utf8');
		t.context = {
		dbDir,
		db: new db_1.DB(`${dbDir}/root.db`),
		};
		});
		test.afterEach(async (t) => {
		await rmfr_1.default(t.context.dbDir);
		});
		test('DB.get returns undefined when no key exists', async (t) => {
		const { db } = t.context;
		t.is(await db.get('test'), undefined);
		});
		test('DB.create creates a new document, returns true, and sets version to 1', async (t) => {
		const { db } = t.context;
		const t0 = utils_1.hrnano();
		const ret = await db.create('test', { a: 1 });
		const doc = await db.getWithMeta('test');
		t.deepEqual(ramda_1.omit(['updatedAt', 'version'], doc), {
		value: { a: 1 },
		patches: [
		{
		version: doc.version,
		ops: [{ op: 'replace', path: '/root', value: { a: 1 } }],
		},
		],
		});
		t.true(doc.updatedAt >= t0);
		t.true(doc.version.major >= t0);
		t.is(doc.version.minor, 1);
		t.true(ret);
		});
		test('DB.create returns false if key already exists', async (t) => {
		const { db } = t.context;
		await db.create('test', { a: 1 });
		t.false(await db.create('test', { a: 2 }));
		});
		test('DB.create throws TypeError when value undefined', async (t) => {
		const { db } = t.context;
		await t.throwsAsync(db.create('test', undefined), {
		instanceOf: TypeError,
		message: /undefined/,
		});
		});
		test('DB.create throws TypeError when value is a function', async (t) => {
		const { db } = t.context;
		await t.throwsAsync(db.create('test', () => 17), {
		instanceOf: TypeError,
		message: /function/,
		});
		});
		test('DB.create throws TypeError when value is a bigint', async (t) => {
		const { db } = t.context;
		await t.throwsAsync(db.create('test', BigInt(17)), {
		instanceOf: TypeError,
		message: /bigint/,
		});
		});
		test('DB.create accepts arbitrary JSONables', async (t) => {
		const { db } = t.context;
		await db.create('test_string', 'hey');
		await db.create('test_number', 7);
		await db.create('test_boolean', true);
		await db.create('test_date', new Date());
		await db.create('test_object', { a: [7] });
		await db.create('test_object', [{ a: 7 }]);
		t.pass();
		});
		test('DB.remove returns false when no key exists', async (t) => {
		const { db } = t.context;
		t.false(await db.remove('test'));
		});
		test('DB.remove returns false when tombstone in key', async (t) => {
		const { db } = t.context;
		await db.create('test', { a: 1 });
		await db.remove('test');
		t.false(await db.remove('test'));
		});
		test('DB.remove removes existing key from DB and returns true', async (t) => {
		const { db } = t.context;
		await db.create('test', { a: 1 });
		t.true(await db.remove('test'));
		t.is(await db.get('test'), undefined);
		});
		test('DB.remove sets a tombstone with an updatedAt attribute', async (t) => {
		const { db } = t.context;
		const t0 = utils_1.hrnano();
		await db.create('test', { a: 1 });
		t.true(await db.remove('test'));
		const doc = await db.getWithMeta('test');
		t.is(doc.value, undefined);
		t.true(doc.updatedAt >= t0);
		});
		test('DB.update creates a new document if key does not exist, returns it, sets version to 1', async (t) => {
		const { db } = t.context;
		const t0 = utils_1.hrnano();
		const next = await db.update('test', (prev) => (Object.assign({}, prev, { a: 1 })));
		const { value, version } = (await db.getWithMeta('test'));
		t.deepEqual(value, { a: 1 });
		t.deepEqual(next, value);
		t.true(version.major >= t0);
		t.is(version.minor, 1);
		});
		test('DB.update updates an existing document, returns it, and increments version', async (t) => {
		const { db } = t.context;
		await db.create('test', { b: 2 });
		const { version: firstVersion } = (await db.getWithMeta('test'));
		const next = await db.update('test', (prev) => (Object.assign({}, prev, { a: 1 })));
		const { value, version } = (await db.getWithMeta('test'));
		t.deepEqual(value, { a: 1, b: 2 });
		t.deepEqual(next, value);
		t.deepEqual(version, db_1.incrVersion(firstVersion));
		});
		test('DB.update does nothing if document not updated', async (t) => {
		const { db } = t.context;
		await db.create('test', { b: 2 });
		const { version: firstVersion } = (await db.getWithMeta('test'));
		const next = await db.update('test', (prev) => (Object.assign({}, prev)));
		const { value, version } = (await db.getWithMeta('test'));
		t.deepEqual(value, { b: 2 });
		t.deepEqual(next, value);
		t.deepEqual(version, firstVersion);
		});
		test('DB.poll returns patches which match requested versions', async (t) => {
		const { db } = t.context;
		await db.create('test1', 'a');
		await db.create('test2', 'a');
		await db.create('test3', 'a');
		await db.create('test4', 'a');
		await db.create('test5', 'a');
		await db.update('test1', () => 'b');
		await db.update('test1', () => 'c');
		await db.update('test2', () => 'b');
		await db.update('test2', () => 'c');
		await db.update('test3', () => 'b');
		await db.remove('test3');
		const [major1, major2, major3, major4, major5,] = await Promise.all(ramda_1.range(1, 5 + 1).map(async (x) => (await db.getWithMeta(`test${x}`)).version.major));
		const keyedPatches = await db.poll([
		['test1', { major: major1, minor: 1 }],
		['test2', { major: major2, minor: 2 }],
		['test3', { major: major3, minor: 1 }],
		['test4', { major: major4, minor: 1 }],
		['test5', { major: major5, minor: 0 }],
		]);
		t.deepEqual(keyedPatches, [
		['test1', [
		{ version: { major: major1, minor: 2 }, ops: [{ op: 'replace', path: '/root', value: 'b' }] },
		{ version: { major: major1, minor: 3 }, ops: [{ op: 'replace', path: '/root', value: 'c' }] },
		]],
		['test2', [
		{ version: { major: major2, minor: 3 }, ops: [{ op: 'replace', path: '/root', value: 'c' }] },
		]],
		['test3', [
		{ version: { major: major3, minor: 2 }, ops: [{ op: 'replace', path: '/root', value: 'b' }] },
		{ version: { major: major3, minor: 3 }, ops: [{ op: 'remove', path: '/root' }] },
		]],
		['test5', [
		{ version: { major: major5, minor: 1 }, ops: [{ op: 'replace', path: '/root', value: 'a' }] },
		]],
		]);
		});
		test('DB.poll returns on update if no new patches stored', async (t) => {
		const { db } = t.context;
		await db.create('test1', 'a');
		const { version } = (await db.getWithMeta('test1'));
		const [keyedPatches] = await Promise.all([
		db.poll([['test1', version]]),
		db.update('test1', () => 'b'),
		]);
		t.deepEqual(keyedPatches, [
		['test1', [
		{ version: db_1.incrVersion(version), ops: [{ op: 'replace', path: '/root', value: 'b' }] },
		]],
		]);
		});
		test('DB.poll returns on remove if no new patches stored', async (t) => {
		const { db } = t.context;
		await db.create('test1', 'a');
		const { version } = (await db.getWithMeta('test1'));
		const [keyedPatches] = await Promise.all([
		db.poll([['test1', version]]),
		db.remove('test1'),
		]);
		t.deepEqual(keyedPatches, [
		['test1', [
		{ version: { major: version.major, minor: 2 }, ops: [{ op: 'remove', path: '/root' }] },
		]],
		]);
		});
		test('DB.poll returns on create if no new patches stored', async (t) => {
		const { db } = t.context;
		const [keyedPatches] = await Promise.all([
		db.poll([['test1', { major: 0, minor: 0 }]]),
		db.create('test1', 'a'),
		]);
		const { version } = (await db.getWithMeta('test1'));
		t.deepEqual(keyedPatches, [
		['test1', [
		{ version, ops: [{ op: 'replace', path: '/root', value: 'a' }] },
		]],
		]);
		});
		test('DB.poll returns empty array when no patches emitted', async (t) => {
		const { db } = t.context;
		const patches = await db.poll([['test1', { major: 0, minor: 0 }]], { readBlockTimeMs: 100 });
		t.deepEqual(patches, []);
		});
		test('DB.poll returns empty array when patches emitted on different key', async (t) => {
		const { db } = t.context;
		const [patches] = await Promise.all([
		db.poll([['test1', { major: 0, minor: 0 }]], { readBlockTimeMs: 100 }),
		db.create('test2', 'a'),
		]);
		t.deepEqual(patches, []);
		});
		test('DB.poll returns empty array when patches emitted on old version', async (t) => {
		const { db } = t.context;
		const [patches] = await Promise.all([
		db.poll([['test1', { major: utils_1.hrnano() + 10000000000, minor: 0 }]], { readBlockTimeMs: 100 }),
		db.create('test1', 'a'),
		]);
		t.deepEqual(patches, []);
		});
		test('DB.create works after remove', async (t) => {
		const { db } = t.context;
		await db.create('test', 7);
		const { version: initialVersion } = (await db.getWithMeta('test'));
		await db.remove('test');
		const t0 = utils_1.hrnano();
		t.true(await db.create('test', 8));
		const doc = await db.getWithMeta('test');
		t.deepEqual(ramda_1.omit(['updatedAt', 'version'], doc), {
		value: 8,
		patches: [
		{
		version: initialVersion,
		ops: [{ op: 'replace', path: '/root', value: 7 }],
		},
		{
		version: db_1.incrVersion(initialVersion),
		ops: [{ op: 'remove', path: '/root' }],
		},
		{
		version: doc.version,
		ops: [{ op: 'replace', path: '/root', value: 8 }],
		},
		],
		});
		t.true(doc.updatedAt >= t0);
		t.true(doc.version.major >= t0);
		t.is(doc.version.minor, 1);
		});
		test('DB.update works after remove but increments version and includes tombstone\'s patches', async (t) => {
		const { db } = t.context;
		await db.create('test', 7);
		const { version: initialVersion } = (await db.getWithMeta('test'));
		await db.remove('test');
		const t0 = utils_1.hrnano();
		const val = await db.update('test', () => 8);
		t.is(val, 8);
		const doc = await db.getWithMeta('test');
		t.deepEqual(ramda_1.omit(['updatedAt', 'version'], doc), {
		value: 8,
		patches: [
		{
		version: initialVersion,
		ops: [{ op: 'replace', path: '/root', value: 7 }],
		},
		{
		version: db_1.incrVersion(initialVersion),
		ops: [{ op: 'remove', path: '/root' }],
		},
		{
		version: doc.version,
		ops: [{ op: 'replace', path: '/root', value: 8 }],
		},
		],
		});
		t.true(doc.updatedAt >= t0);
		t.true(doc.version.major >= t0);
		t.is(doc.version.minor, 1);
		});
		test('DB.update throws TypeError if updater returned undefined', async (t) => {
		const { db } = t.context;
		await t.throwsAsync(db.update('test', () => undefined), TypeError);
		});
		test('DB.update throws TypeError if trying to modify returned object', async (t) => {
		const { db } = t.context;
		await db.create('test', { a: 1, b: { c: 2, d: [5] } });
		await t.throwsAsync(db.update('test', (obj) => {
		obj.a = 2;
		return obj;
		}), TypeError);
		await t.throwsAsync(db.update('test', (obj) => {
		obj.b.c = 3;
		return obj;
		}), TypeError);
		await t.throwsAsync(db.update('test', (obj) => {
		obj.b.d[0] = 6;
		return obj;
		}), TypeError);
		});
		//# sourceMappingURL=db.spec.js.map

-1

dist/test/db.spec.js.map

-2

dist/test/query.spec.d.ts

		export {};
		//# sourceMappingURL=query.spec.d.ts.map

-1

dist/test/query.spec.d.ts.map

{"version":3,"file":"query.spec.d.ts","sourceRoot":"","sources":["../../src/test/query.spec.ts"],"names":[],"mappings":""}

-205

dist/test/query.spec.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		const ava_1 = __importDefault(require("ava"));
		const errors_1 = require("../errors");
		const query_1 = require("../query");
		function stringifyThenParse(v) {
		return JSON.parse(JSON.stringify(v));
		}
		ava_1.default('key builds a filter on document key', (t) => {
		t.deepEqual(stringifyThenParse(query_1.key.eq('abc')), { path: ['key'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('value builds a filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.value.eq('abc')), { path: ['value'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('value.field() builds a nested filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.value.field('a.b').eq('abc')), { path: ['value', 'a.b'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('value.field(number) casts path to string', (t) => {
		t.deepEqual(stringifyThenParse(query_1.value.field(7).eq('abc')), { path: ['value', '7'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('value.field(reserved field) generates a path', (t) => {
		t.deepEqual(stringifyThenParse(query_1.value.field('eq').eq('abc')), { path: ['value', 'eq'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('value proxy builds a nested filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.value.x.eq('abc')), { path: ['value', 'x'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('typedField builds a filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.value.typedField('a').eq('abc')), { path: ['value', 'a'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('typedValue builds a filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().eq('abc')), { path: ['value'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('typedValue proxy builds a nested filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().a.eq(6)), { path: ['value', 'a'], operator: 'eq', value: 6 });
		});
		ava_1.default('typedValue proxy builds an array filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue()[0].eq('abc')), { path: ['value', '0'], operator: 'eq', value: 'abc' });
		});
		ava_1.default('typedValue proxy builds a complex nested filter on document value', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().z[0].x[5].eq(true)), { path: ['value', 'z', '0', 'x', '5'], operator: 'eq', value: true });
		});
		ava_1.default('typedValue proxy supports optional fields', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().z.exists()), { path: ['value', 'z'], operator: 'exists' });
		t.deepEqual(stringifyThenParse(query_1.typedValue().z.eq(3)), { path: ['value', 'z'], operator: 'eq', value: 3 });
		});
		ava_1.default('typedValue proxy supports optional array values', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue()[0].exists()), { path: ['value', '0'], operator: 'exists' });
		t.deepEqual(stringifyThenParse(query_1.typedValue()[0].eq(3)), { path: ['value', '0'], operator: 'eq', value: 3 });
		});
		ava_1.default('typedValue supports null', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().z.isNull()), { path: ['value', 'z'], operator: 'isNull' });
		t.deepEqual(stringifyThenParse(query_1.typedValue().z.as().isNull()), { path: ['value', 'z'], operator: 'isNull' });
		t.deepEqual(stringifyThenParse(query_1.typedValue().z.as().eq(3)), { path: ['value', 'z'], operator: 'eq', value: 3 });
		});
		ava_1.default('ne builds a gt filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().ne(false)), { path: ['value'], operator: 'ne', value: false });
		});
		ava_1.default('gt builds a gt filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().gt(7)), { path: ['value'], operator: 'gt', value: 7 });
		});
		ava_1.default('lt builds an lt filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().lt('abc')), { path: ['value'], operator: 'lt', value: 'abc' });
		});
		ava_1.default('gte builds a gte filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().gte(7)), { path: ['value'], operator: 'gte', value: 7 });
		});
		ava_1.default('lte builds an lte filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().lte('abc')), { path: ['value'], operator: 'lte', value: 'abc' });
		});
		ava_1.default('exists is available on non optional fields', (t) => {
		const val = query_1.typedValue();
		t.deepEqual(stringifyThenParse(val.x.exists()), { path: ['value', 'x'], operator: 'exists' });
		t.deepEqual(stringifyThenParse(val.x.y.exists()), { path: ['value', 'x', 'y'], operator: 'exists' });
		});
		ava_1.default('matches builds a match filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().matches('abc')), { path: ['value'], operator: 'matches', pattern: 'abc', caseInsensitive: false });
		t.deepEqual(stringifyThenParse(query_1.typedValue().matches('abc', true)), { path: ['value'], operator: 'matches', pattern: 'abc', caseInsensitive: true });
		t.deepEqual(stringifyThenParse(query_1.typedValue().matches(/abc/)), { path: ['value'], operator: 'matches', pattern: 'abc', caseInsensitive: false });
		t.deepEqual(stringifyThenParse(query_1.typedValue().matches(/abc/i)), { path: ['value'], operator: 'matches', pattern: 'abc', caseInsensitive: true });
		});
		ava_1.default('matches throws when given unsupported flags', (t) => {
		t.throws(() => query_1.key.matches(/abc/g));
		});
		ava_1.default('startsWith builds a startsWith filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.typedValue().startsWith('abc')), { path: ['value'], operator: 'startsWith', value: 'abc' });
		});
		ava_1.default('all builds a valid filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.all(query_1.key.startsWith('/games/'), query_1.value.x.eq(5))), {
		operator: 'and',
		filters: [
		{ path: ['key'], operator: 'startsWith', value: '/games/' },
		{ path: ['value', 'x'], operator: 'eq', value: 5 },
		],
		});
		});
		ava_1.default('all throws a TypeError if not given a filter', (t) => {
		t.throws(() => query_1.all('a'), TypeError);
		});
		ava_1.default('all throws an IllegalArgumentError if not given any arguemnts', (t) => {
		t.throws(() => query_1.all(), errors_1.IllegalArgumentError);
		});
		ava_1.default('any builds a valid filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.any(query_1.key.startsWith('/games/'), query_1.value.y.gt(7))), {
		operator: 'or',
		filters: [
		{ path: ['key'], operator: 'startsWith', value: '/games/' },
		{ path: ['value', 'y'], operator: 'gt', value: 7 },
		],
		});
		});
		ava_1.default('any throws a TypeError if not given a filter', (t) => {
		t.throws(() => query_1.any('a'), TypeError);
		});
		ava_1.default('any throws an IllegalArgumentError if not given any arguemnts', (t) => {
		t.throws(() => query_1.any(), errors_1.IllegalArgumentError);
		});
		ava_1.default('not builds a valid filter', (t) => {
		t.deepEqual(stringifyThenParse(query_1.not(query_1.key.startsWith('/games/'))), {
		operator: 'not',
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		});
		});
		ava_1.default('not throws a TypeError if not given a filter', (t) => {
		t.throws(() => query_1.not('a'), TypeError);
		});
		ava_1.default('filter builds a new query', (t) => {
		t.deepEqual(stringifyThenParse(query_1.filter(query_1.key.startsWith('/games/'))), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		});
		});
		ava_1.default('filter throws if not given a Filter', (t) => {
		t.throws(() => query_1.filter('abc'), TypeError);
		});
		ava_1.default('Query.filter combines filters with logical AND', (t) => {
		t.deepEqual(stringifyThenParse(query_1.filter(query_1.key.startsWith('/games/')).filter(query_1.value.eq(7))), {
		filter: {
		operator: 'and',
		filters: [
		{ path: ['key'], operator: 'startsWith', value: '/games/' },
		{ path: ['value'], operator: 'eq', value: 7 },
		],
		},
		});
		});
		ava_1.default('Query.filter throws if not given a Filter', (t) => {
		const q = query_1.filter(query_1.key.eq('abc'));
		t.throws(() => q.filter('abc'), TypeError);
		});
		const baseQ = query_1.filter(query_1.key.startsWith('/games/'));
		const limitQ = baseQ.limit(7);
		ava_1.default('Query.limit sets a limit', (t) => {
		t.deepEqual(stringifyThenParse(limitQ), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		limit: 7,
		});
		});
		ava_1.default('Query.limit overrides if current limit > new limit l', (t) => {
		t.deepEqual(stringifyThenParse(limitQ.limit(6)), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		limit: 6,
		});
		});
		ava_1.default('Query.limit does nothing if current limit = new limit', (t) => {
		t.deepEqual(stringifyThenParse(limitQ.limit(7)), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		limit: 7,
		});
		});
		ava_1.default('Query.limit throws an IllegalArgumentError if increasing current limit', (t) => {
		t.throws(() => limitQ.limit(8), errors_1.IllegalArgumentError);
		});
		ava_1.default('Query.limit throws an IllegalArgumentError if setting limit to a value less than 1', (t) => {
		t.throws(() => limitQ.limit(0), errors_1.IllegalArgumentError);
		});
		ava_1.default('Query.skip sets skip', (t) => {
		t.deepEqual(stringifyThenParse(baseQ.skip(3)), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		skip: 3,
		});
		});
		ava_1.default('Query.orderBy sets order', (t) => {
		t.deepEqual(stringifyThenParse(baseQ.orderBy(query_1.value.x)), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		orderBy: [{ path: ['value', 'x'], direction: query_1.ASC }],
		});
		});
		ava_1.default('Query.orderBy sets DESC order', (t) => {
		t.deepEqual(stringifyThenParse(baseQ.orderBy(query_1.value.x, query_1.DESC)), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		orderBy: [{ path: ['value', 'x'], direction: query_1.DESC }],
		});
		});
		ava_1.default('Query.orderBy sets secondary order', (t) => {
		t.deepEqual(stringifyThenParse(baseQ.orderBy(query_1.value.x).orderBy(query_1.key)), {
		filter: { path: ['key'], operator: 'startsWith', value: '/games/' },
		orderBy: [{ path: ['value', 'x'], direction: query_1.ASC }, { path: ['key'], direction: query_1.ASC }],
		});
		});
		ava_1.default('Query.orderBy throws an IllegalArgumentError when ordering by same path twice', (t) => {
		t.throws(() => baseQ.orderBy(query_1.value.x).orderBy(query_1.value.x), errors_1.IllegalArgumentError);
		});
		//# sourceMappingURL=query.spec.js.map

-1

dist/test/query.spec.js.map

-12

dist/utils.d.ts

		export declare class TimeoutError extends Error {
		readonly name = "TimeoutError";
		}
		export declare const withTimeout: <T>(promise: Promise<T>, timeout?: number) => Promise<T>;
		export declare const noop: () => undefined;
		export declare function deferred<T>(): {
		promise: Promise<T>;
		resolve: (value?: T \| PromiseLike<T> \| undefined) => void;
		reject: (reason?: any) => void;
		};
		export declare function hrnano(): number;
		//# sourceMappingURL=utils.d.ts.map

-1

dist/utils.d.ts.map

{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;IACrC,SAAgB,IAAI,kBAAkB;CACvC;AAGD,eAAO,MAAM,WAAW,0DAcvB,CAAC;AAEF,eAAO,MAAM,IAAI,iBAAkB,CAAC;AAEpC,wBAAgB,QAAQ,CAAC,CAAC;;;;EAazB;AAID,wBAAgB,MAAM,WAGrB"}

-48

dist/utils.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		class TimeoutError extends Error {
		constructor() {
		super(...arguments);
		this.name = 'TimeoutError';
		}
		}
		exports.TimeoutError = TimeoutError;
		// Tests not included since this code is borrowed from a utility library
		exports.withTimeout = async (promise, timeout = 5000) => {
		let handle;
		const timeoutPromise = new Promise((_, reject) => {
		handle = setTimeout(() => reject(new TimeoutError('Timeout')), timeout);
		});
		try {
		return await Promise.race([
		promise,
		timeoutPromise,
		]);
		}
		finally {
		clearTimeout(handle);
		}
		};
		exports.noop = () => undefined;
		function deferred() {
		// resolve and reject have to be initialized to prevent typescript from complaining that they're uninitialized
		let resolve = exports.noop;
		let reject = exports.noop;
		const promise = new Promise((_resolve, _reject) => {
		resolve = _resolve;
		reject = _reject;
		});
		return {
		promise,
		resolve,
		reject,
		};
		}
		exports.deferred = deferred;
		const NS_PER_SEC = 1e9;
		function hrnano() {
		const [a, b] = process.hrtime();
		return a * NS_PER_SEC + b;
		}
		exports.hrnano = hrnano;
		//# sourceMappingURL=utils.js.map

-1

dist/utils.js.map

{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;AAAA,MAAa,YAAa,SAAQ,KAAK;IAAvC;;QACkB,SAAI,GAAG,cAAc,CAAC;IACxC,CAAC;CAAA;AAFD,oCAEC;AAED,wEAAwE;AAC3D,QAAA,WAAW,GAAG,KAAK,EAAK,OAAmB,EAAE,UAAkB,IAAI,EAAc,EAAE;IAC9F,IAAI,MAAkC,CAAC;IACvC,MAAM,cAAc,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;QAC/C,MAAM,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,IAAI;QACF,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC;YACxB,OAAO;YACP,cAAc;SACf,CAAe,CAAC;KAClB;YAAS;QACR,YAAY,CAAC,MAAO,CAAC,CAAC;KACvB;AACH,CAAC,CAAC;AAEW,QAAA,IAAI,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC;AAEpC,SAAgB,QAAQ;IACtB,8GAA8G;IAC9G,IAAI,OAAO,GAAqD,YAAI,CAAC;IACrE,IAAI,MAAM,GAA2B,YAAI,CAAC;IAC1C,MAAM,OAAO,GAAG,IAAI,OAAO,CAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;QACnD,OAAO,GAAG,QAAQ,CAAC;QACnB,MAAM,GAAG,OAAO,CAAC;IACnB,CAAC,CAAC,CAAC;IACH,OAAO;QACL,OAAO;QACP,OAAO;QACP,MAAM;KACP,CAAC;AACJ,CAAC;AAbD,4BAaC;AAED,MAAM,UAAU,GAAG,GAAG,CAAC;AAEvB,SAAgB,MAAM;IACpB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAChC,OAAO,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;AAC5B,CAAC;AAHD,wBAGC"}

-21

LICENSE

		MIT License

		Copyright (c) 2018-2019 Binaris, Inc. and its affiliates.

		Permission is hereby granted, free of charge, to any person obtaining a copy
		of this software and associated documentation files (the "Software"), to deal
		in the Software without restriction, including without limitation the rights
		to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
		copies of the Software, and to permit persons to whom the Software is
		furnished to do so, subject to the following conditions:

		The above copyright notice and this permission notice shall be included in all
		copies or substantial portions of the Software.

		THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
		OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
		SOFTWARE.

@binaris/shift-db - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes