@forge/kvs 0.0.2-next.0 → 0.0.2-next.2

package/out/__test__/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/out/__test__/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/__test__/index.test.ts"],"names":[],"mappings":""}

package/out/__test__/index.test.js

@@ -0,0 +1,509 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const conditions_1 = require("../conditions");
+const entity_query_1 = require("../entity-query");
+const errors_1 = require("../errors");
+const types_1 = require("../interfaces/types");
+const kvs_1 = require("../kvs");
+const storage_api_1 = require("../storage-api");
+function prepare(response) {
+    const apiClient = jest.fn().mockResolvedValueOnce(response);
+    const storageApi = new storage_api_1.StorageApi(apiClient);
+    const sut = new kvs_1.KvsImpl(storageApi);
+    return {
+        apiClient,
+        storageApi,
+        sut
+    };
+}
+describe('KVS', () => {
+    const traceId = 'traceId';
+    it('should get correctly', async () => {
+        const response = new Response(JSON.stringify({ key: 'foo', value: 'bar' }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.get('foo');
+        expect(rs).toEqual('bar');
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/get', expect.objectContaining({
+            body: JSON.stringify({ key: 'foo' })
+        }));
+    });
+    it('should handle not found error', async () => {
+        const response = new Response(JSON.stringify({ code: 'KEY_NOT_FOUND', message: 'Provided key does not exist' }), {
+            status: 404,
+            statusText: 'Not Found',
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut } = prepare(response);
+        await expect(sut.get('foo')).rejects.toMatchError(new errors_1.ForgeKvsAPIError({ status: 404, statusText: 'Not Found', traceId }, { code: 'KEY_NOT_FOUND', message: 'Provided key does not exist' }));
+    });
+    it('should handle unexpected response', async () => {
+        const response = new Response(JSON.stringify({ code: 'INTERNAL_SERVER_ERROR', message: 'An internal server error has occurred' }), {
+            status: 500,
+            statusText: 'Internal Server Error',
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut } = prepare(response);
+        await expect(sut.get('foo')).rejects.toMatchError(new errors_1.ForgeKvsAPIError({ status: 500, statusText: 'Internal Server Error', traceId }, { code: 'INTERNAL_SERVER_ERROR', message: 'An internal server error has occurred' }));
+    });
+    it('should handle non-json response even though status is ok', async () => {
+        const response = new Response('Some non JSON response that will fail to parse', {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut } = prepare(response);
+        await expect(sut.get('foo')).rejects.toMatchError(new errors_1.ForgeKvsError('Unexpected error. Response was not valid JSON: Some non JSON response that will fail to parse'));
+    });
+    it('should getSecret correctly', async () => {
+        const response = new Response(JSON.stringify({ key: 'foo', value: 'bar' }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.getSecret('foo');
+        expect(rs).toEqual('bar');
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/secret/get', expect.objectContaining({
+            body: JSON.stringify({ key: 'foo' })
+        }));
+    });
+    it('should getEntity correctly', async () => {
+        const response = new Response(JSON.stringify({ key: 'foo', value: { name: 'Jane Doe' } }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.entity('employees').get('foo');
+        expect(rs).toEqual({ name: 'Jane Doe' });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/get', expect.objectContaining({
+            body: JSON.stringify({ entityName: 'employees', key: 'foo' })
+        }));
+    });
+    it('should set correctly', async () => {
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.set('foo', 'bar');
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/set', expect.objectContaining({
+            body: JSON.stringify({ key: 'foo', value: 'bar' })
+        }));
+    });
+    it('should setSecret correctly', async () => {
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.setSecret('foo', 'bar');
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/secret/set', expect.objectContaining({
+            body: JSON.stringify({ key: 'foo', value: 'bar' })
+        }));
+    });
+    it('should setEntity correctly', async () => {
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.entity('employees').set('foo', { name: 'Jane Doe' });
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/set', expect.objectContaining({
+            body: JSON.stringify({ entityName: 'employees', key: 'foo', value: { name: 'Jane Doe' } })
+        }));
+    });
+    it('should delete correctly', async () => {
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.delete('foo');
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/delete', expect.objectContaining({
+            body: JSON.stringify({ key: 'foo' })
+        }));
+    });
+    it('should deleteSecret correctly', async () => {
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.deleteSecret('foo');
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/secret/delete', expect.objectContaining({
+            body: JSON.stringify({ key: 'foo' })
+        }));
+    });
+    it('should deleteEntity correctly', async () => {
+        const response = new Response(undefined, {
+            status: 204,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.entity('employees').delete('foo');
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/delete', expect.objectContaining({
+            body: JSON.stringify({ entityName: 'employees', key: 'foo' })
+        }));
+    });
+    it('should query correctly', async () => {
+        const response = new Response(JSON.stringify({ cursor: 'third-page', data: [{ key: 'foo', value: 'bar' }] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut
+            .query()
+            .cursor('second-page')
+            .limit(1)
+            .where('key', conditions_1.WhereConditions.beginsWith('fo'))
+            .getMany();
+        expect(rs).toEqual({
+            results: [{ key: 'foo', value: 'bar' }],
+            nextCursor: 'third-page'
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/query', expect.objectContaining({
+            body: JSON.stringify({
+                limit: 1,
+                after: 'second-page',
+                where: [{ property: 'key', condition: 'BEGINS_WITH', values: ['fo'] }]
+            })
+        }));
+    });
+    it('should getOne out of a list of results', async () => {
+        const response = new Response(JSON.stringify({
+            data: [
+                { key: 'foo', value: 'bar' },
+                { key: 'bar', value: 'foo' }
+            ]
+        }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.query().getOne();
+        expect(rs).toEqual({ key: 'foo', value: 'bar' });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/query', expect.objectContaining({
+            body: JSON.stringify({ limit: 1 })
+        }));
+    });
+    it('should default to undefined when getOne receives an empty list', async () => {
+        const response = new Response(JSON.stringify({ data: [] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.query().getOne();
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/query', expect.objectContaining({
+            body: JSON.stringify({ limit: 1 })
+        }));
+    });
+    it('should query entity correctly and pass partition with index', async () => {
+        const response = new Response(JSON.stringify({ data: [{ key: 'foo', value: { name: 'Jane Doe' } }] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut
+            .entity('employees')
+            .query()
+            .index('by-employmentyear', { partition: [2000] })
+            .getMany();
+        expect(rs).toEqual({
+            results: [{ key: 'foo', value: { name: 'Jane Doe' } }]
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-employmentyear',
+                partition: [2000]
+            })
+        }));
+    });
+    it('should query entity correctly (without any filters)', async () => {
+        const response = new Response(JSON.stringify({ data: [{ key: 'foo', value: { name: 'Jane Doe' } }] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut
+            .entity('employees')
+            .query()
+            .index('by-key')
+            .where(conditions_1.WhereConditions.beginsWith('f'))
+            .sort(types_1.Sort.ASC)
+            .limit(100)
+            .cursor('second-page')
+            .getMany();
+        expect(rs).toEqual({
+            results: [{ key: 'foo', value: { name: 'Jane Doe' } }]
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-key',
+                range: { condition: 'BEGINS_WITH', values: ['f'] },
+                sort: 'ASC',
+                limit: 100,
+                cursor: 'second-page'
+            })
+        }));
+    });
+    it('should query entity correctly (with "or" filters)', async () => {
+        const response = new Response(JSON.stringify({ data: [{ key: 'foo', value: { name: 'Jane Doe' } }] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const filter = new entity_query_1.FilterBuilder()
+            .or('age', conditions_1.FilterConditions.greaterThan(30))
+            .or('age', conditions_1.FilterConditions.lessThan(35));
+        const rs = await sut
+            .entity('employees')
+            .query()
+            .index('by-key')
+            .where(conditions_1.WhereConditions.beginsWith('f'))
+            .filters(filter)
+            .getMany();
+        expect(rs).toEqual({
+            results: [{ key: 'foo', value: { name: 'Jane Doe' } }]
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-key',
+                range: { condition: 'BEGINS_WITH', values: ['f'] },
+                filters: {
+                    or: [
+                        { property: 'age', condition: 'GREATER_THAN', values: [30] },
+                        { property: 'age', condition: 'LESS_THAN', values: [35] }
+                    ]
+                }
+            })
+        }));
+    });
+    it('should query entity correctly (with "and" filters)', async () => {
+        const response = new Response(JSON.stringify({ data: [{ key: 'foo', value: { name: 'Jane Doe' } }] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut
+            .entity('employees')
+            .query()
+            .index('by-key')
+            .where(conditions_1.WhereConditions.beginsWith('f'))
+            .filters(new entity_query_1.FilterBuilder()
+            .and('age', conditions_1.FilterConditions.greaterThan(30))
+            .and('employmentyear', conditions_1.FilterConditions.lessThan(2000)))
+            .getMany();
+        expect(rs).toEqual({
+            results: [{ key: 'foo', value: { name: 'Jane Doe' } }]
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-key',
+                range: { condition: 'BEGINS_WITH', values: ['f'] },
+                filters: {
+                    and: [
+                        { property: 'age', condition: 'GREATER_THAN', values: [30] },
+                        { property: 'employmentyear', condition: 'LESS_THAN', values: [2000] }
+                    ]
+                }
+            })
+        }));
+    });
+    it('should getOne entity out of a list', async () => {
+        const response = new Response(JSON.stringify({
+            data: [
+                { key: 'foo', value: { name: 'Jane Foo' } },
+                { key: 'bar', value: { name: 'Jane Bar' } }
+            ]
+        }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut
+            .entity('employees')
+            .query()
+            .index('by-key')
+            .where(conditions_1.WhereConditions.beginsWith('f'))
+            .getOne();
+        expect(rs).toEqual({ key: 'foo', value: { name: 'Jane Foo' } });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-key',
+                range: { condition: 'BEGINS_WITH', values: ['f'] },
+                limit: 1
+            })
+        }));
+    });
+    it('should default to undefined when getOne entity receives an empty list', async () => {
+        const response = new Response(JSON.stringify({ data: [] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut
+            .entity('employees')
+            .query()
+            .index('by-key')
+            .where(conditions_1.WhereConditions.beginsWith('f'))
+            .getOne();
+        expect(rs).toBeUndefined();
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-key',
+                range: { condition: 'BEGINS_WITH', values: ['f'] },
+                limit: 1
+            })
+        }));
+    });
+    it.each([
+        {
+            title: 'between',
+            condition: conditions_1.WhereConditions.between(10, 20),
+            expectedPayload: { condition: 'BETWEEN', values: [10, 20] }
+        },
+        {
+            title: 'beginsWith',
+            condition: conditions_1.WhereConditions.beginsWith('foo'),
+            expectedPayload: { condition: 'BEGINS_WITH', values: ['foo'] }
+        },
+        {
+            title: 'equalTo',
+            condition: conditions_1.WhereConditions.equalTo('foo'),
+            expectedPayload: { condition: 'EQUAL_TO', values: ['foo'] }
+        },
+        {
+            title: 'greaterThan',
+            condition: conditions_1.WhereConditions.greaterThan(10),
+            expectedPayload: { condition: 'GREATER_THAN', values: [10] }
+        },
+        {
+            title: 'greaterThanEqualTo',
+            condition: conditions_1.WhereConditions.greaterThanEqualTo(10),
+            expectedPayload: { condition: 'GREATER_THAN_EQUAL_TO', values: [10] }
+        },
+        {
+            title: 'lessThan',
+            condition: conditions_1.WhereConditions.lessThan(10),
+            expectedPayload: { condition: 'LESS_THAN', values: [10] }
+        },
+        {
+            title: 'lessThanEqualTo',
+            condition: conditions_1.WhereConditions.lessThanEqualTo(10),
+            expectedPayload: { condition: 'LESS_THAN_EQUAL_TO', values: [10] }
+        }
+    ])('should test $title all where conditions', async ({ condition, expectedPayload }) => {
+        const response = new Response(JSON.stringify({ data: [{ key: 'foo', value: { name: 'Jane Doe' } }] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut.entity('employees').query().index('by-key').where(condition).getMany();
+        expect(rs).toEqual({
+            results: [{ key: 'foo', value: { name: 'Jane Doe' } }]
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-key',
+                range: expectedPayload
+            })
+        }));
+    });
+    it.each([
+        {
+            title: 'between',
+            condition: conditions_1.FilterConditions.between(10, 20),
+            expectedPayload: { condition: 'BETWEEN', values: [10, 20] }
+        },
+        {
+            title: 'beginsWith',
+            condition: conditions_1.FilterConditions.beginsWith('foo'),
+            expectedPayload: { condition: 'BEGINS_WITH', values: ['foo'] }
+        },
+        { title: 'exists', condition: conditions_1.FilterConditions.exists(), expectedPayload: { condition: 'EXISTS', values: [true] } },
+        {
+            title: 'notExists',
+            condition: conditions_1.FilterConditions.notExists(),
+            expectedPayload: { condition: 'NOT_EXISTS', values: [true] }
+        },
+        {
+            title: 'greaterThan',
+            condition: conditions_1.FilterConditions.greaterThan(10),
+            expectedPayload: { condition: 'GREATER_THAN', values: [10] }
+        },
+        {
+            title: 'greaterThanEqualTo',
+            condition: conditions_1.FilterConditions.greaterThanEqualTo(10),
+            expectedPayload: { condition: 'GREATER_THAN_EQUAL_TO', values: [10] }
+        },
+        {
+            title: 'lessThan',
+            condition: conditions_1.FilterConditions.lessThan(10),
+            expectedPayload: { condition: 'LESS_THAN', values: [10] }
+        },
+        {
+            title: 'lessThanEqualTo',
+            condition: conditions_1.FilterConditions.lessThanEqualTo(10),
+            expectedPayload: { condition: 'LESS_THAN_EQUAL_TO', values: [10] }
+        },
+        {
+            title: 'contains',
+            condition: conditions_1.FilterConditions.contains('foo'),
+            expectedPayload: { condition: 'CONTAINS', values: ['foo'] }
+        },
+        {
+            title: 'notContains',
+            condition: conditions_1.FilterConditions.notContains('foo'),
+            expectedPayload: { condition: 'NOT_CONTAINS', values: ['foo'] }
+        },
+        {
+            title: 'equalTo',
+            condition: conditions_1.FilterConditions.equalTo('foo'),
+            expectedPayload: { condition: 'EQUAL_TO', values: ['foo'] }
+        },
+        {
+            title: 'notEqualTo',
+            condition: conditions_1.FilterConditions.notEqualTo('foo'),
+            expectedPayload: { condition: 'NOT_EQUAL_TO', values: ['foo'] }
+        }
+    ])('should test $title all filter conditions', async ({ condition, expectedPayload }) => {
+        const response = new Response(JSON.stringify({ data: [{ key: 'foo', value: { name: 'Jane Doe' } }] }), {
+            status: 200,
+            headers: { 'x-trace-id': traceId }
+        });
+        const { sut, apiClient } = prepare(response);
+        const rs = await sut
+            .entity('employees')
+            .query()
+            .index('by-key')
+            .filters(new entity_query_1.FilterBuilder().and('name', condition))
+            .getMany();
+        expect(rs).toEqual({
+            results: [{ key: 'foo', value: { name: 'Jane Doe' } }]
+        });
+        expect(apiClient).toHaveBeenCalledWith('/api/v1/entity/query', expect.objectContaining({
+            body: JSON.stringify({
+                entityName: 'employees',
+                indexName: 'by-key',
+                filters: {
+                    and: [{ property: 'name', ...expectedPayload }]
+                }
+            })
+        }));
+    });
+});

package/out/conditions.d.ts

@@ -0,0 +1,38 @@
+import { BeginsWithClause, BetweenClause, ContainsClause, EqualToClause, ExistsClause, GreaterThanClause, GreaterThanEqualToClause, LessThanClause, LessThanEqualToClause, NotContainsClause, NotEqualToClause, NotExistsClause, StringOrNumber, StringOrNumberOrBoolean } from './interfaces/types';
+declare function between<T extends StringOrNumber>(firstValue: T, secondValue: T): BetweenClause<T>;
+declare function beginsWith(value: StringOrNumber): BeginsWithClause;
+declare function exists(): ExistsClause;
+declare function notExists(): NotExistsClause;
+declare function greaterThan(value: StringOrNumber): GreaterThanClause;
+declare function greaterThanEqualTo(value: StringOrNumber): GreaterThanEqualToClause;
+declare function lessThan(value: StringOrNumber): LessThanClause;
+declare function lessThanEqualTo(value: StringOrNumber): LessThanEqualToClause;
+declare function contains(value: string): ContainsClause;
+declare function notContains(value: string): NotContainsClause;
+declare function equalTo(value: StringOrNumberOrBoolean): EqualToClause;
+declare function notEqualTo(value: StringOrNumberOrBoolean): NotEqualToClause;
+export declare const WhereConditions: {
+    beginsWith: typeof beginsWith;
+    between: typeof between;
+    equalTo: typeof equalTo;
+    greaterThan: typeof greaterThan;
+    greaterThanEqualTo: typeof greaterThanEqualTo;
+    lessThan: typeof lessThan;
+    lessThanEqualTo: typeof lessThanEqualTo;
+};
+export declare const FilterConditions: {
+    beginsWith: typeof beginsWith;
+    between: typeof between;
+    contains: typeof contains;
+    notContains: typeof notContains;
+    equalTo: typeof equalTo;
+    notEqualTo: typeof notEqualTo;
+    exists: typeof exists;
+    notExists: typeof notExists;
+    greaterThan: typeof greaterThan;
+    greaterThanEqualTo: typeof greaterThanEqualTo;
+    lessThan: typeof lessThan;
+    lessThanEqualTo: typeof lessThanEqualTo;
+};
+export {};
+//# sourceMappingURL=conditions.d.ts.map

package/out/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../src/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,wBAAwB,EACxB,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,oBAAoB,CAAC;AAE5B,iBAAS,OAAO,CAAC,CAAC,SAAS,cAAc,EAAE,UAAU,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAK1F;AAED,iBAAS,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,gBAAgB,CAK3D;AAED,iBAAS,MAAM,IAAI,YAAY,CAK9B;AAED,iBAAS,SAAS,IAAI,eAAe,CAKpC;AAED,iBAAS,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,iBAAiB,CAK7D;AAED,iBAAS,kBAAkB,CAAC,KAAK,EAAE,cAAc,GAAG,wBAAwB,CAK3E;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAKvD;AAED,iBAAS,eAAe,CAAC,KAAK,EAAE,cAAc,GAAG,qBAAqB,CAKrE;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAK/C;AAED,iBAAS,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAKrD;AAED,iBAAS,OAAO,CAAC,KAAK,EAAE,uBAAuB,GAAG,aAAa,CAK9D;AAED,iBAAS,UAAU,CAAC,KAAK,EAAE,uBAAuB,GAAG,gBAAgB,CAKpE;AAED,eAAO,MAAM,eAAe;;;;;;;;CAQ3B,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAa5B,CAAC"}

package/out/conditions.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterConditions = exports.WhereConditions = void 0;
+function between(firstValue, secondValue) {
+    return {
+        condition: 'BETWEEN',
+        values: [firstValue, secondValue]
+    };
+}
+function beginsWith(value) {
+    return {
+        condition: 'BEGINS_WITH',
+        values: [value]
+    };
+}
+function exists() {
+    return {
+        condition: 'EXISTS',
+        values: [true]
+    };
+}
+function notExists() {
+    return {
+        condition: 'NOT_EXISTS',
+        values: [true]
+    };
+}
+function greaterThan(value) {
+    return {
+        condition: 'GREATER_THAN',
+        values: [value]
+    };
+}
+function greaterThanEqualTo(value) {
+    return {
+        condition: 'GREATER_THAN_EQUAL_TO',
+        values: [value]
+    };
+}
+function lessThan(value) {
+    return {
+        condition: 'LESS_THAN',
+        values: [value]
+    };
+}
+function lessThanEqualTo(value) {
+    return {
+        condition: 'LESS_THAN_EQUAL_TO',
+        values: [value]
+    };
+}
+function contains(value) {
+    return {
+        condition: 'CONTAINS',
+        values: [value]
+    };
+}
+function notContains(value) {
+    return {
+        condition: 'NOT_CONTAINS',
+        values: [value]
+    };
+}
+function equalTo(value) {
+    return {
+        condition: 'EQUAL_TO',
+        values: [value]
+    };
+}
+function notEqualTo(value) {
+    return {
+        condition: 'NOT_EQUAL_TO',
+        values: [value]
+    };
+}
+exports.WhereConditions = {
+    beginsWith,
+    between,
+    equalTo,
+    greaterThan,
+    greaterThanEqualTo,
+    lessThan,
+    lessThanEqualTo
+};
+exports.FilterConditions = {
+    beginsWith,
+    between,
+    contains,
+    notContains,
+    equalTo,
+    notEqualTo,
+    exists,
+    notExists,
+    greaterThan,
+    greaterThanEqualTo,
+    lessThan,
+    lessThanEqualTo
+};

package/out/entity-query.d.ts

@@ -0,0 +1,13 @@
+import { EntityFilterClauses, AndFilter, EntityQueryBuilder, IndexQueryBuilder, Filter, IndexOptions, OrFilter } from './interfaces/entity-query';
+import { StorageApi } from './storage-api';
+export declare class KvsIndexQueryBuilder<T> implements IndexQueryBuilder<T> {
+    private readonly entityName;
+    private readonly storageApi;
+    constructor(entityName: string, storageApi: StorageApi);
+    index(name: string, indexOptions?: IndexOptions<T>): EntityQueryBuilder<T>;
+}
+export declare class FilterBuilder<T> implements Filter<T> {
+    and(field: keyof T, condition: EntityFilterClauses): AndFilter<T>;
+    or(field: keyof T, condition: EntityFilterClauses): OrFilter<T>;
+}
+//# sourceMappingURL=entity-query.d.ts.map

package/out/entity-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-query.d.ts","sourceRoot":"","sources":["../src/entity-query.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAGnB,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,MAAM,EAEN,YAAY,EACZ,QAAQ,EACT,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,qBAAa,oBAAoB,CAAC,CAAC,CAAE,YAAW,iBAAiB,CAAC,CAAC,CAAC;IAEhE,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;gBADV,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,UAAU;IAGzC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC;CAQ3E;AAgED,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAChD,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,mBAAmB,GAAG,SAAS,CAAC,CAAC,CAAC;IAIjE,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,mBAAmB,GAAG,QAAQ,CAAC,CAAC,CAAC;CAGhE"}