@based/db 0.1.5 → 0.2.0

package/dist/src/client/query/subscription/toByteCode.js

@@ -0,0 +1,139 @@
+import { writeInt64, writeUint16, writeUint32 } from '@based/utils';
+import native from '../../../native.js';
+import { ID } from '../toByteCode/offsets.js';
+import { QueryType } from '../types.js';
+import { SubscriptionType } from './types.js';
+export const collectFilters = (filter, fields, nowQueries = []) => {
+    if (filter.hasSubMeta) {
+        for (const [prop, conditions] of filter.conditions) {
+            if (fields) {
+                fields.add(prop);
+            }
+            for (const condition of conditions) {
+                if (condition.subscriptionMeta) {
+                    if (condition.subscriptionMeta.now) {
+                        nowQueries.push(...condition.subscriptionMeta.now);
+                    }
+                }
+            }
+        }
+    }
+    else {
+        for (const prop of filter.conditions.keys()) {
+            if (fields) {
+                fields.add(prop);
+            }
+        }
+    }
+    if (filter.or) {
+        collectFilters(filter.or, fields, nowQueries);
+    }
+    if (filter.and) {
+        collectFilters(filter.and, fields, nowQueries);
+    }
+    if (filter.references) {
+        for (const [prop, ref] of filter.references) {
+            if (fields) {
+                fields.add(prop);
+            }
+            collectFilters(ref, undefined, nowQueries);
+        }
+    }
+    return nowQueries;
+};
+export const collectFields = (def) => {
+    const fields = new Set();
+    if (def.include.main.len > 0) {
+        fields.add(0);
+    }
+    for (const prop of def.include.props.values()) {
+        fields.add(prop.def.prop);
+    }
+    for (const prop of def.references.keys()) {
+        fields.add(prop);
+    }
+    return fields;
+};
+export const collectTypes = (def, types = new Set()) => {
+    if ('references' in def) {
+        for (const ref of def.references.values()) {
+            types.add(ref.schema.id);
+            // TODO Now queries here...
+            collectTypes(ref, types);
+        }
+    }
+    if ('filter' in def && 'references' in def.filter) {
+        for (const ref of def.filter.references.values()) {
+            types.add(ref.schema.id);
+            collectTypes(ref);
+        }
+    }
+    return types;
+};
+export const registerSubscription = (query) => {
+    if (query.def.queryType === QueryType.id) {
+        // @ts-ignore
+        const id = query.def.target.id;
+        const fields = collectFields(query.def);
+        const typeId = query.def.schema.id;
+        const subId = native.crc32(query.buffer.subarray(ID.id + 4, query.buffer.byteLength - 4));
+        const headerLen = 16;
+        const types = collectTypes(query.def);
+        const nowQueries = collectFilters(query.def.filter, fields);
+        const buffer = new Uint8Array(headerLen + fields.size + types.size * 2 + nowQueries.length * 16);
+        buffer[0] = SubscriptionType.singleId;
+        writeUint32(buffer, subId, 1);
+        writeUint16(buffer, typeId, 5);
+        writeUint32(buffer, id, 7);
+        buffer[11] = fields.size;
+        writeUint16(buffer, types.size, 12);
+        writeUint16(buffer, nowQueries.length, 14);
+        let i = headerLen;
+        for (const field of fields) {
+            buffer[i] = field;
+            i++;
+        }
+        for (const type of types) {
+            writeUint16(buffer, type, i);
+            i += 2;
+        }
+        for (const now of nowQueries) {
+            buffer[i] = now.prop.prop;
+            buffer[i + 1] = now.ctx.operation;
+            writeUint16(buffer, now.ctx.typeId, i + 2);
+            writeInt64(buffer, now.offset, i + 4);
+            writeUint32(buffer, now.resolvedByteIndex, i + 12);
+            i += 16;
+        }
+        query.subscriptionBuffer = buffer;
+    }
+    else {
+        const typeId = query.def.schema.id;
+        const types = collectTypes(query.def);
+        const nowQueries = collectFilters(query.def.filter, new Set());
+        const typeLen = types.has(typeId) ? types.size - 1 : types.size;
+        const headerLen = 8;
+        const buffer = new Uint8Array(headerLen + typeLen * 2 + nowQueries.length * 16);
+        buffer[0] = SubscriptionType.fullType;
+        writeUint16(buffer, typeId, 1);
+        writeUint16(buffer, typeLen, 3);
+        writeUint16(buffer, nowQueries.length, 5); // hopefully you dont have more then 255 now filters...
+        let i = headerLen;
+        for (const typeIdIt of types) {
+            if (typeIdIt !== typeId) {
+                writeUint16(buffer, typeIdIt, i);
+                i += 2;
+            }
+        }
+        for (const now of nowQueries) {
+            buffer[i] = now.prop.prop;
+            buffer[i + 1] = now.ctx.operation;
+            writeUint16(buffer, now.ctx.typeId, i + 2);
+            writeInt64(buffer, now.offset, i + 4);
+            writeUint32(buffer, now.resolvedByteIndex, i + 12);
+            i += 16;
+        }
+        query.subscriptionBuffer = buffer;
+    }
+};
+//# sourceMappingURL=toByteCode.js.map

package/dist/src/client/query/subscription/types.d.ts

@@ -3,3 +3,9 @@ export type OnData = (res: BasedQueryResponse) => any;
 export type OnError = (err: Error) => any;
 export type OnClose = () => any;
 export type OnSubscription = (res: any, err?: Error) => void;
+export declare enum SubscriptionType {
+    fullType = 0,
+    singleId = 1,
+    timeBasedSingleId = 2,// If any time in there just put it as 200ms for now...
+    timeBasedMulti = 3
+}

package/dist/src/client/query/subscription/types.js

@@ -1,10 +1,8 @@
-export {};
-// export type Subscription = {
-//   query: BasedDbQuery
-//   subs: Set<OnSubscription>
-//   res?: BasedQueryResponse
-//   closed: boolean
-//   inProgress: boolean // dont need to check
-//   // filter - realy nice to add
-// }
+export var SubscriptionType;
+(function (SubscriptionType) {
+    SubscriptionType[SubscriptionType["fullType"] = 0] = "fullType";
+    SubscriptionType[SubscriptionType["singleId"] = 1] = "singleId";
+    SubscriptionType[SubscriptionType["timeBasedSingleId"] = 2] = "timeBasedSingleId";
+    SubscriptionType[SubscriptionType["timeBasedMulti"] = 3] = "timeBasedMulti";
+})(SubscriptionType || (SubscriptionType = {}));
 //# sourceMappingURL=types.js.map

package/dist/src/client/query/toByteCode/aggregates.d.ts

@@ -0,0 +1,2 @@
+import { QueryDef, IntermediateByteCode } from '../types.js';
+export declare const aggregatesQuery: (def: QueryDef) => IntermediateByteCode;

package/dist/src/client/query/toByteCode/aggregates.js

@@ -0,0 +1,60 @@
+import { filterToBuffer } from '../query.js';
+import { QueryDefType, QueryType, } from '../types.js';
+import { aggregateToBuffer, isRootCountOnly, } from '../aggregates/aggregation.js';
+export const aggregatesQuery = (def) => {
+    const aggregateSize = def.aggregate.size || 0;
+    if (aggregateSize === 0) {
+        throw new Error('Wrong aggregate size (0)');
+    }
+    const filterSize = def.filter.size || 0;
+    if (def.type === QueryDefType.References) {
+        const buf = new Uint8Array(12 + filterSize + aggregateSize); // op + refSize + filterSize + offset + typeId + refField
+        const sz = 9 + filterSize + aggregateSize; // filterSize + offset + typeId + refField
+        buf[0] = 2 /* includeOp.REFS_AGGREGATION */;
+        buf[1] = sz;
+        buf[2] = sz >>> 8;
+        buf[3] = filterSize;
+        buf[4] = filterSize >>> 8;
+        buf[5] = def.range.offset;
+        buf[6] = def.range.offset >>> 8;
+        buf[7] = def.range.offset >>> 16;
+        buf[8] = def.range.offset >>> 24;
+        if (filterSize) {
+            buf.set(filterToBuffer(def.filter, 9), 9);
+        }
+        // required to get typeEntry and fieldSchema
+        buf[9 + filterSize] = def.schema.idUint8[0]; // typeId
+        buf[9 + 1 + filterSize] = def.schema.idUint8[1]; // typeId
+        buf[9 + 2 + filterSize] = def.target.propDef.prop; // refField
+        const aggregateBuffer = aggregateToBuffer(def.aggregate);
+        buf.set(aggregateBuffer, 9 + 3 + filterSize);
+        return { buffer: buf, def, needsMetaResolve: def.filter.hasSubMeta };
+    }
+    else {
+        const buf = new Uint8Array(16 + filterSize + aggregateSize);
+        buf[0] = isRootCountOnly(def, filterSize)
+            ? QueryType.aggregatesCountType
+            : QueryType.aggregates;
+        buf[1] = def.schema.idUint8[0];
+        buf[2] = def.schema.idUint8[1];
+        buf[3] = def.range.offset;
+        buf[4] = def.range.offset >>> 8;
+        buf[5] = def.range.offset >>> 16;
+        buf[6] = def.range.offset >>> 24;
+        buf[7] = def.range.limit;
+        buf[8] = def.range.limit >>> 8;
+        buf[9] = def.range.limit >>> 16;
+        buf[10] = def.range.limit >>> 24;
+        buf[11] = filterSize;
+        buf[12] = filterSize >>> 8;
+        if (filterSize) {
+            buf.set(filterToBuffer(def.filter, 13), 13);
+        }
+        const aggregateBuffer = aggregateToBuffer(def.aggregate);
+        buf[14 + filterSize] = aggregateSize;
+        buf[15 + filterSize] = aggregateSize >>> 8;
+        buf.set(aggregateBuffer, 16 + filterSize);
+        return { buffer: buf, def, needsMetaResolve: def.filter.hasSubMeta };
+    }
+};
+//# sourceMappingURL=aggregates.js.map

package/dist/src/client/query/toByteCode/alias.d.ts

@@ -0,0 +1,2 @@
+import { QueryDef, IntermediateByteCode } from '../types.js';
+export declare const aliasQuery: (def: QueryDef) => IntermediateByteCode;

package/dist/src/client/query/toByteCode/alias.js

@@ -0,0 +1,24 @@
+import { filterToBuffer } from '../query.js';
+import { QueryType } from '../types.js';
+import { ENCODER, writeUint16 } from '@based/utils';
+export const aliasQuery = (def) => {
+    const filterSize = def.filter.size || 0;
+    const alias = def.target.resolvedAlias;
+    const aliasStr = ENCODER.encode(alias.value);
+    const aliasLen = aliasStr.byteLength;
+    const buf = new Uint8Array(8 + filterSize + aliasLen);
+    buf[0] = QueryType.alias;
+    writeUint16(buf, def.schema.id, 1);
+    buf[3] = alias.def.prop;
+    buf[4] = aliasLen;
+    buf[5] = aliasLen >>> 8;
+    buf.set(aliasStr, 6);
+    buf[6 + aliasLen] = filterSize;
+    buf[7 + aliasLen] = filterSize >>> 8;
+    if (filterSize) {
+        const x = filterToBuffer(def.filter, 8 + aliasLen);
+        buf.set(x, 8 + aliasLen);
+    }
+    return { buffer: buf, def, needsMetaResolve: def.filter.hasSubMeta };
+};
+//# sourceMappingURL=alias.js.map

package/dist/src/client/query/toByteCode/default.d.ts

@@ -1,2 +1,2 @@
-import { QueryDef } from '../types.js';
-export declare const defaultQuery: (def: QueryDef, filterSize: number, sortSize: number, searchSize: number, sort: Uint8Array, search: Uint8Array) => Uint8Array<ArrayBuffer>;
+import { QueryDef, IntermediateByteCode } from '../types.js';
+export declare const defaultQuery: (def: QueryDef, filterSize: number, sortSize: number, searchSize: number, sort: Uint8Array, search: Uint8Array) => IntermediateByteCode;

package/dist/src/client/query/toByteCode/default.js

@@ -1,38 +1,35 @@
 import { filterToBuffer, isSimpleMainFilter } from '../query.js';
 import { QueryType } from '../types.js';
+import { writeUint16, writeUint32 } from '@based/utils';
+import { DEFAULT } from './offsets.js';
 export const defaultQuery = (def, filterSize, sortSize, searchSize, sort, search) => {
-    const buf = new Uint8Array(18 + filterSize + sortSize + searchSize);
+    const buffer = new Uint8Array(DEFAULT.baseSize + filterSize + sortSize + searchSize);
     let index = 0;
-    buf[index++] = QueryType.default;
-    buf[index++] = def.schema.idUint8[0];
-    buf[index++] = def.schema.idUint8[1];
-    buf[index++] = def.range.offset;
-    buf[index++] = def.range.offset >>> 8;
-    buf[index++] = def.range.offset >>> 16;
-    buf[index++] = def.range.offset >>> 24;
-    buf[index++] = def.range.limit;
-    buf[index++] = def.range.limit >>> 8;
-    buf[index++] = def.range.limit >>> 16;
-    buf[index++] = def.range.limit >>> 24;
-    buf[index++] = filterSize;
-    buf[index++] = filterSize >>> 8;
-    buf[index++] = filterSize && isSimpleMainFilter(def.filter) ? 1 : 0;
+    buffer[index++] = QueryType.default;
+    writeUint16(buffer, def.schema.id, index);
+    index += 2;
+    writeUint32(buffer, def.range.offset, index);
+    index += 4;
+    writeUint32(buffer, def.range.limit, index);
+    index += 4;
+    writeUint16(buffer, filterSize, index);
+    index += 2;
+    buffer[index++] = filterSize && isSimpleMainFilter(def.filter) ? 1 : 0;
     if (filterSize) {
-        buf.set(filterToBuffer(def.filter), index);
+        buffer.set(filterToBuffer(def.filter, index), index);
         index += filterSize;
     }
-    buf[index++] = sortSize;
-    buf[index++] = sortSize >>> 8;
+    writeUint16(buffer, sortSize, index);
+    index += 2;
     if (sortSize) {
-        buf.set(sort, index);
+        buffer.set(sort, index);
         index += sortSize;
     }
-    buf[index++] = searchSize;
-    buf[index++] = searchSize >>> 8;
+    writeUint16(buffer, searchSize, index);
+    index += 2;
     if (searchSize) {
-        buf.set(search, index);
-        index += searchSize;
+        buffer.set(search, index);
     }
-    return buf;
+    return { buffer, def, needsMetaResolve: def.filter.hasSubMeta };
 };
 //# sourceMappingURL=default.js.map

package/dist/src/client/query/toByteCode/id.d.ts

@@ -0,0 +1,2 @@
+import { QueryDef, IntermediateByteCode } from '../types.js';
+export declare const idQuery: (def: QueryDef) => IntermediateByteCode;

package/dist/src/client/query/toByteCode/id.js

@@ -0,0 +1,17 @@
+import { filterToBuffer } from '../query.js';
+import { QueryType } from '../types.js';
+import { writeUint16, writeUint32 } from '@based/utils';
+import { ID } from './offsets.js';
+export const idQuery = (def) => {
+    const filterSize = def.filter.size || 0;
+    const buffer = new Uint8Array(ID.baseSize + filterSize);
+    buffer[ID.queryType] = QueryType.id;
+    writeUint16(buffer, def.schema.id, ID.type);
+    writeUint32(buffer, def.target.id, ID.id);
+    writeUint16(buffer, filterSize, ID.filterSize);
+    if (filterSize) {
+        buffer.set(filterToBuffer(def.filter, ID.filter), ID.filter);
+    }
+    return { buffer, def, needsMetaResolve: def.filter.hasSubMeta };
+};
+//# sourceMappingURL=id.js.map

package/dist/src/client/query/toByteCode/ids.d.ts

@@ -0,0 +1,2 @@
+import { QueryDef, IntermediateByteCode } from '../types.js';
+export declare const idsQuery: (def: QueryDef) => IntermediateByteCode;

package/dist/src/client/query/toByteCode/ids.js

@@ -0,0 +1,52 @@
+import { filterToBuffer } from '../query.js';
+import { QueryType } from '../types.js';
+import { searchToBuffer } from '../search/index.js';
+import { createSortBuffer } from '../sort.js';
+import { writeUint16, writeUint32 } from '@based/utils';
+import { IDS } from './offsets.js';
+export const idsQuery = (def) => {
+    const filterSize = def.filter.size || 0;
+    let sort;
+    let sortSize = 0;
+    if (def.sort) {
+        sort = createSortBuffer(def.sort);
+        sortSize = sort.byteLength;
+    }
+    let search;
+    let searchSize = 0;
+    if (def.search) {
+        search = searchToBuffer(def.search);
+        searchSize = def.search.size;
+    }
+    const idsSize = def.target.ids.length * 4;
+    const buffer = new Uint8Array(IDS.baseSize + idsSize + filterSize + sortSize + searchSize);
+    let index = 0;
+    buffer[IDS.queryType] = QueryType.ids;
+    writeUint16(buffer, def.schema.id, IDS.type);
+    writeUint32(buffer, idsSize, IDS.idsSize);
+    buffer.set(new Uint8Array(def.target.ids.buffer), IDS.idsValue);
+    index = IDS.idsValue + idsSize;
+    writeUint32(buffer, def.range.offset, index);
+    index += 4;
+    writeUint32(buffer, def.range.limit, index);
+    index += 4;
+    writeUint16(buffer, filterSize, index);
+    index += 2;
+    if (filterSize) {
+        buffer.set(filterToBuffer(def.filter, index), index);
+        index += filterSize;
+    }
+    writeUint16(buffer, sortSize, index);
+    index += 2;
+    if (sortSize) {
+        buffer.set(sort, index);
+        index += sortSize;
+    }
+    writeUint16(buffer, searchSize, index);
+    index += 2;
+    if (searchSize) {
+        buffer.set(search, index);
+    }
+    return { buffer, def, needsMetaResolve: def.filter.hasSubMeta };
+};
+//# sourceMappingURL=ids.js.map

package/dist/src/client/query/toByteCode/offsets.d.ts

@@ -0,0 +1,35 @@
+export declare const ID: {
+    baseSize: number;
+    queryType: number;
+    type: number;
+    id: number;
+    filterSize: number;
+    filter: number;
+};
+export declare const IDS: {
+    baseSize: number;
+    queryType: number;
+    type: number;
+    idsSize: number;
+    idsValue: number;
+};
+export declare const REFERENCES: {
+    baseSize: number;
+    includeOp: number;
+    size: number;
+    filterSize: number;
+    sortSize: number;
+    offset: number;
+    limit: number;
+    filter: number;
+};
+export declare const REFERENCE: {
+    baseSize: number;
+    includeOp: number;
+    sizeOffset: number;
+    type: number;
+    prop: number;
+};
+export declare const DEFAULT: {
+    baseSize: number;
+};

package/dist/src/client/query/toByteCode/offsets.js

@@ -0,0 +1,36 @@
+export const ID = {
+    baseSize: 9, // queryType(1) + type(2) + id(4) + filterSize(2)
+    queryType: 0,
+    type: 1,
+    id: 3,
+    filterSize: 7,
+    filter: 9,
+};
+export const IDS = {
+    baseSize: 21, // queryType(1) + type(2) + idsSize(4) + offset(4) + limit(4) + filterSize(2) + sortSize(2) + searchSize(2)
+    queryType: 0,
+    type: 1,
+    idsSize: 3,
+    idsValue: 7,
+};
+export const REFERENCES = {
+    baseSize: 18, // includeOp(1) + size(2) + filterSize(2) + sortSize(2) + offset(4) + limit(4) + type(2) + prop(1)
+    includeOp: 0,
+    size: 1,
+    filterSize: 3,
+    sortSize: 5,
+    offset: 7,
+    limit: 11,
+    filter: 15,
+};
+export const REFERENCE = {
+    baseSize: 6, // includeOp(1) + size(2) + type(2) + prop(1)
+    includeOp: 0,
+    sizeOffset: 1,
+    type: 3,
+    prop: 5,
+};
+export const DEFAULT = {
+    baseSize: 18, // queryType(1) + type(2) + offset(4) + limit(4) + filterSize(2) + isSimple(1) + sortSize(2) + searchSize(2)
+};
+//# sourceMappingURL=offsets.js.map

package/dist/src/client/query/toByteCode/reference.d.ts

@@ -0,0 +1,2 @@
+import { QueryDef, IntermediateByteCode } from '../types.js';
+export declare const referenceQuery: (def: QueryDef, size: number) => IntermediateByteCode;

package/dist/src/client/query/toByteCode/reference.js

@@ -0,0 +1,12 @@
+import { writeUint16 } from '@based/utils';
+import { REFERENCE } from './offsets.js';
+export const referenceQuery = (def, size) => {
+    const buffer = new Uint8Array(REFERENCE.baseSize);
+    const sz = size + 3;
+    buffer[REFERENCE.includeOp] = 5 /* includeOp.REFERENCE */;
+    writeUint16(buffer, sz, REFERENCE.sizeOffset);
+    writeUint16(buffer, def.schema.id, REFERENCE.type);
+    buffer[REFERENCE.prop] = def.target.propDef.prop;
+    return { buffer, def, needsMetaResolve: def.filter.hasSubMeta };
+};
+//# sourceMappingURL=reference.js.map

package/dist/src/client/query/toByteCode/references.d.ts

@@ -0,0 +1,2 @@
+import { QueryDef, IntermediateByteCode } from '../types.js';
+export declare const referencesQuery: (def: QueryDef, size: number) => IntermediateByteCode;

package/dist/src/client/query/toByteCode/references.js

@@ -0,0 +1,35 @@
+import { filterToBuffer } from '../query.js';
+import { createSortBuffer } from '../sort.js';
+import { writeUint16, writeUint32 } from '@based/utils';
+import { REFERENCES } from './offsets.js';
+export const referencesQuery = (def, size) => {
+    const filterSize = def.filter.size || 0;
+    let sort;
+    let sortSize = 0;
+    if (def.sort) {
+        sort = createSortBuffer(def.sort);
+        sortSize = sort.byteLength;
+    }
+    const modsSize = filterSize + sortSize;
+    const buffer = new Uint8Array(REFERENCES.baseSize + modsSize);
+    const sz = size + 7 + modsSize + 8;
+    buffer[REFERENCES.includeOp] = 4 /* includeOp.REFERENCES */;
+    writeUint16(buffer, sz, REFERENCES.size);
+    writeUint16(buffer, filterSize, REFERENCES.filterSize);
+    writeUint16(buffer, sortSize, REFERENCES.sortSize);
+    writeUint32(buffer, def.range.offset, REFERENCES.offset);
+    writeUint32(buffer, def.range.limit, REFERENCES.limit);
+    let index = REFERENCES.filter;
+    if (filterSize) {
+        buffer.set(filterToBuffer(def.filter, index), index);
+        index += filterSize;
+    }
+    if (sort) {
+        buffer.set(sort, index);
+        index += sortSize;
+    }
+    writeUint16(buffer, def.schema.id, index);
+    buffer[index + 2] = def.target.propDef.prop;
+    return { buffer, def, needsMetaResolve: def.filter.hasSubMeta };
+};
+//# sourceMappingURL=references.js.map

package/dist/src/client/query/toByteCode/toByteCode.d.ts

@@ -1,3 +1,5 @@
-import { QueryDef } from '../types.js';
+import { IntermediateByteCode, QueryDef } from '../types.js';
 import { DbClient } from '../../index.js';
-export declare function defToBuffer(db: DbClient, def: QueryDef): Uint8Array[];
+import { BasedDbQuery } from '../BasedDbQuery.js';
+export declare function defToBuffer(db: DbClient, def: QueryDef): IntermediateByteCode[];
+export declare const queryToBuffer: (query: BasedDbQuery) => Uint8Array<ArrayBuffer>;