@based/db 0.0.52 → 0.0.56

package/dist/src/client/query/BasedDbQuery.js

@@ -1,4 +1,4 @@
-import { createQueryDef, QueryDefType, filter, sort, defToBuffer, filterOr, isAlias, includeField, includeFields, addAggregate, groupBy, } from './query.js';
+import { filter, sort, filterOr, isAlias, includeField, includeFields, addAggregate, groupBy, } from './query.js';
 import { BasedQueryResponse } from './BasedIterable.js';
 import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef, } from './include/utils.js';
 import { FilterBranch } from './filter/FilterBranch.js';
@@ -11,7 +11,6 @@ import { langCodesMap } from '@based/schema';
 import { convertFilter } from './filter/convertFilter.js';
 import { validateLocale, validateRange } from './validation.js';
 import { DEF_RANGE_PROP_LIMIT } from './thresholds.js';
-import { concatUint8Arr } from '@saulx/utils';
 import { displayTarget } from './display.js';
 import picocolors from 'picocolors';
 export class QueryBranch {
@@ -25,11 +24,13 @@ export class QueryBranch {
     sort(field, order = 'asc') {
         if (this.queryCommands) {
             this.queryCommands.push({
-                method: 'filter',
+                method: 'sort',
                 args: [field, order],
             });
         }
-        sort(this.def, field, order);
+        else {
+            sort(this.def, field, order);
+        }
         // @ts-ignore
         return this;
     }
@@ -40,12 +41,14 @@ export class QueryBranch {
                 args: [field, operator, value, opts],
             });
         }
-        const f = convertFilter(this.def, field, operator, value, opts);
-        if (!f) {
-            // @ts-ignore
-            return this;
+        else {
+            const f = convertFilter(this.def, field, operator, value, opts);
+            if (!f) {
+                // @ts-ignore
+                return this;
+            }
+            filter(this.db, this.def, f, this.def.filter);
         }
-        filter(this.db, this.def, f, this.def.filter);
         // @ts-ignore
         return this;
     }
@@ -56,7 +59,9 @@ export class QueryBranch {
                 args: [f],
             });
         }
-        filter(this.db, this.def, f, this.def.filter);
+        else {
+            filter(this.db, this.def, f, this.def.filter);
+        }
         // @ts-ignore
         return this;
     }
@@ -67,56 +72,58 @@ export class QueryBranch {
                 args: [query, field, opts, ...fields],
             });
         }
-        if (ArrayBuffer.isView(query)) {
-            // @ts-ignore
-            vectorSearch(this.def, query, field, opts ?? {});
-            // @ts-ignore
-            return this;
-        }
-        if (field) {
-            if (!fields) {
-                // @ts-ignore
-                fields = [field];
-            }
-            else {
+        else {
+            if (ArrayBuffer.isView(query)) {
                 // @ts-ignore
-                fields.unshift(field);
-            }
-        }
-        if (opts) {
-            if (!fields) {
+                vectorSearch(this.def, query, field, opts ?? {});
                 // @ts-ignore
-                fields = [opts];
+                return this;
             }
-            else {
-                // @ts-ignore
-                fields.unshift(opts);
+            if (field) {
+                if (!fields) {
+                    // @ts-ignore
+                    fields = [field];
+                }
+                else {
+                    // @ts-ignore
+                    fields.unshift(field);
+                }
             }
-        }
-        if (fields.length) {
-            if (fields.length === 1) {
-                search(this.def, query, fields[0]);
+            if (opts) {
+                if (!fields) {
+                    // @ts-ignore
+                    fields = [opts];
+                }
+                else {
+                    // @ts-ignore
+                    fields.unshift(opts);
+                }
             }
-            else {
-                const s = {};
-                for (const f of fields) {
-                    if (typeof f === 'string') {
-                        s[f] = 0;
-                    }
-                    else if (Array.isArray(f)) {
-                        for (const ff of f) {
-                            s[ff] = 0;
+            if (fields.length) {
+                if (fields.length === 1) {
+                    search(this.def, query, fields[0]);
+                }
+                else {
+                    const s = {};
+                    for (const f of fields) {
+                        if (typeof f === 'string') {
+                            s[f] = 0;
+                        }
+                        else if (Array.isArray(f)) {
+                            for (const ff of f) {
+                                s[ff] = 0;
+                            }
+                        }
+                        else if (typeof f === 'object') {
+                            Object.assign(s, f);
                         }
                     }
-                    else if (typeof f === 'object') {
-                        Object.assign(s, f);
-                    }
+                    search(this.def, query, s);
                 }
-                search(this.def, query, s);
             }
-        }
-        else {
-            search(this.def, query);
+            else {
+                search(this.def, query);
+            }
         }
         // @ts-ignore
         return this;
@@ -128,7 +135,9 @@ export class QueryBranch {
                 args: [field],
             });
         }
-        groupBy(this.def, field);
+        else {
+            groupBy(this.def, field);
+        }
         // only works with aggregates for now
         // @ts-ignore
         return this;
@@ -140,19 +149,26 @@ export class QueryBranch {
                 args: [field],
             });
         }
-        const p = field.split('.');
-        addAggregate(2 /* AggregateType.COUNT */, this.def, p);
+        else {
+            const p = field.split('.');
+            addAggregate(2 /* AggregateType.COUNT */, this.def, p);
+        }
         // @ts-ignore
         return this;
     }
     sum(...fields) {
+        if (fields.length === 0) {
+            throw new Error('Empty sum() called');
+        }
         if (this.queryCommands) {
             this.queryCommands.push({
                 method: 'sum',
                 args: fields,
             });
         }
-        addAggregate(1 /* AggregateType.SUM */, this.def, fields);
+        else {
+            addAggregate(1 /* AggregateType.SUM */, this.def, fields);
+        }
         // @ts-ignore
         return this;
     }
@@ -163,15 +179,17 @@ export class QueryBranch {
                 args: [field, operator, value, opts],
             });
         }
-        if (typeof field === 'function') {
-            const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.def.filter), this.def);
-            field(f);
-            this.def.filter.size += f.filterBranch.size;
-        }
         else {
-            const f = convertFilter(this.def, field, operator, value, opts);
-            if (f) {
-                filterOr(this.db, this.def, f, this.def.filter);
+            if (typeof field === 'function') {
+                const f = new FilterBranch(this.db, filterOr(this.db, this.def, [], this.def.filter), this.def);
+                field(f);
+                this.def.filter.size += f.filterBranch.size;
+            }
+            else {
+                const f = convertFilter(this.def, field, operator, value, opts);
+                if (f) {
+                    filterOr(this.db, this.def, f, this.def.filter);
+                }
             }
         }
         // @ts-ignore
@@ -181,16 +199,18 @@ export class QueryBranch {
         if (this.queryCommands) {
             this.queryCommands.push({ method: 'range', args: [start, end] });
         }
-        const offset = start;
-        const limit = end - start;
-        if (validateRange(this.def, offset, limit)) {
-            this.def.range.offset = 0;
-            this.def.range.limit = DEF_RANGE_PROP_LIMIT;
-            // @ts-ignore
-            return this;
+        else {
+            const offset = start;
+            const limit = end - start;
+            if (validateRange(this.def, offset, limit)) {
+                this.def.range.offset = 0;
+                this.def.range.limit = DEF_RANGE_PROP_LIMIT;
+                // @ts-ignore
+                return this;
+            }
+            this.def.range.offset = offset;
+            this.def.range.limit = limit;
         }
-        this.def.range.offset = offset;
-        this.def.range.limit = limit;
         // @ts-ignore
         return this;
     }
@@ -198,49 +218,51 @@ export class QueryBranch {
         if (this.queryCommands) {
             this.queryCommands.push({ method: 'include', args: fields });
         }
-        for (const f of fields) {
-            if (typeof f === 'string') {
-                includeField(this.def, f);
-            }
-            else if (typeof f === 'function') {
-                f((field) => {
-                    if (field[0] == '$') {
-                        // @ts-ignore
-                        const prop = this.def.target?.propDef?.edges[field];
-                        if (prop &&
-                            (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
-                            const refDef = createOrGetEdgeRefQueryDef(this.db, this.def, prop);
+        else {
+            for (const f of fields) {
+                if (typeof f === 'string') {
+                    includeField(this.def, f);
+                }
+                else if (typeof f === 'function') {
+                    f((field) => {
+                        if (field[0] == '$') {
                             // @ts-ignore
-                            return new QueryBranch(this.db, refDef);
+                            const prop = this.def.target?.propDef?.edges[field];
+                            if (prop &&
+                                (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
+                                const refDef = createOrGetEdgeRefQueryDef(this.db, this.def, prop);
+                                // @ts-ignore
+                                return new QueryBranch(this.db, refDef);
+                            }
+                            throw new Error(`No edge reference or edge references field named "${field}"`);
                         }
-                        throw new Error(`No edge reference or edge references field named "${field}"`);
+                        else {
+                            const prop = field[0] == '$'
+                                ? // @ts-ignore
+                                    this.def.target?.propDef?.edges[field]
+                                : this.def.props[field];
+                            if (prop &&
+                                (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
+                                const refDef = createOrGetRefQueryDef(this.db, this.def, prop);
+                                // @ts-ignore
+                                return new QueryBranch(this.db, refDef);
+                            }
+                            throw new Error(`No reference or references field named "${field}"`);
+                        }
+                    });
+                }
+                else if (Array.isArray(f)) {
+                    if (f.length === 0) {
+                        includeFields(this.def, ['id']);
                     }
                     else {
-                        const prop = field[0] == '$'
-                            ? // @ts-ignore
-                                this.def.target?.propDef?.edges[field]
-                            : this.def.props[field];
-                        if (prop &&
-                            (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
-                            const refDef = createOrGetRefQueryDef(this.db, this.def, prop);
-                            // @ts-ignore
-                            return new QueryBranch(this.db, refDef);
-                        }
-                        throw new Error(`No reference or references field named "${field}"`);
+                        includeFields(this.def, f);
                     }
-                });
-            }
-            else if (Array.isArray(f)) {
-                if (f.length === 0) {
-                    includeFields(this.def, ['id']);
                 }
-                else {
-                    includeFields(this.def, f);
+                else if (f !== undefined) {
+                    throw new Error('Invalid include statement: expected props, refs and edges (string or array) or function');
                 }
             }
-            else if (f !== undefined) {
-                throw new Error('Invalid include statement: expected props, refs and edges (string or array) or function');
-            }
         }
         // @ts-ignore
         return this;
@@ -283,35 +305,26 @@ export class BasedDbQuery extends QueryBranch {
                 }
             }
         }
-        if (!db.schema) {
-            throw new Error('Query: No schema yet - use await db.schemaIsSet()');
-        }
-        const def = createQueryDef(db, QueryDefType.Root, target, skipValidation);
-        def.schemaChecksum = db.schema?.hash || 0;
-        super(db, def);
+        // const def = createQueryDef(db, QueryDefType.Root, target, skipValidation)
+        // def.schemaChecksum = db.schema?.hash || 0
+        //  def: QueryDef
+        super(db);
         this.db = db;
         this.skipValidation = skipValidation;
         this.queryCommands = [];
         this.target = target;
     }
-    reBuildQuery() {
+    reset() {
         this.id = undefined;
         this.buffer = undefined;
-        const def = createQueryDef(this.db, QueryDefType.Root, this.target, this.skipValidation);
-        def.schemaChecksum = this.db.schema?.hash || 0;
-        this.def = def;
-        const q = this.queryCommands;
-        this.queryCommands = [];
-        for (const command of q) {
-            this[command.method](...command.args);
-        }
+        this.def = undefined;
     }
     #getInternal = async (resolve, reject) => {
-        if (!this.def.include.stringFields.size && !this.def.references.size) {
-            includeField(this.def, '*');
-        }
         let buf;
         try {
+            if (!this.db.schema) {
+                await this.db.once('schema');
+            }
             buf = registerQuery(this);
         }
         catch (err) {
@@ -321,14 +334,14 @@ export class BasedDbQuery extends QueryBranch {
         const d = performance.now();
         await this.db.isModified();
         if (this.db.schema?.hash !== this.def.schemaChecksum) {
-            this.reBuildQuery();
+            this.reset();
             return this.#getInternal(resolve, reject);
         }
         const res = await this.db.hooks.getQueryBuf(buf);
         if (res.byteLength === 1) {
             if (res[0] === 0) {
                 if (this.db.schema?.hash !== this.def.schemaChecksum) {
-                    this.reBuildQuery();
+                    this.reset();
                     return this.#getInternal(resolve, reject);
                 }
                 reject(new Error('schema mismatch'));
@@ -354,8 +367,16 @@ export class BasedDbQuery extends QueryBranch {
         registerQuery(this);
     }
     locale(locale) {
-        validateLocale(this.def, locale);
-        this.def.lang = langCodesMap.get(locale) ?? 0;
+        if (this.queryCommands) {
+            this.queryCommands.push({
+                method: 'locale',
+                args: [locale],
+            });
+        }
+        else {
+            validateLocale(this.def, locale);
+            this.def.lang = langCodesMap.get(locale) ?? 0;
+        }
         return this;
     }
     subscribe(onData, onError) {
@@ -377,20 +398,10 @@ export class BasedDbQuery extends QueryBranch {
             }));
     }
     _getSync(dbCtxExternal) {
-        if (!this.def.include.stringFields.size && !this.def.references.size) {
-            includeField(this.def, '*');
-        }
         const buf = registerQuery(this);
         const d = performance.now();
         const res = native.getQueryBuf(buf, dbCtxExternal);
         return new BasedQueryResponse(this.id, this.def, new Uint8Array(res), performance.now() - d);
     }
-    toBuffer() {
-        if (!this.def.include.stringFields.size && !this.def.references.size) {
-            includeField(this.def, '*');
-        }
-        const b = defToBuffer(this.db, this.def);
-        return concatUint8Arr(b);
-    }
 }
 //# sourceMappingURL=BasedDbQuery.js.map

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

@@ -131,6 +131,9 @@ export const isRootCountOnly = (def, filterSize) => {
     if (aggs[0].type !== 2 /* AggregateType.COUNT */) {
         return false;
     }
+    if (def.filter && def.filter.size > 0) {
+        return false;
+    }
     return true;
 };
 //# sourceMappingURL=aggregation.js.map

package/dist/src/client/query/registerQuery.js

@@ -2,8 +2,24 @@ import native from '../../native.js';
 import { concatUint8Arr } from '@saulx/utils';
 import { defToBuffer } from './toByteCode/toBuffer.js';
 import { handleErrors } from './validation.js';
+import { createQueryDef } from './queryDef.js';
+import { QueryDefType } from './types.js';
+import { includeField } from './query.js';
 export const registerQuery = (q) => {
     if (!q.id) {
+        const commands = q.queryCommands;
+        q.queryCommands = null;
+        const def = createQueryDef(q.db, QueryDefType.Root, q.target, q.skipValidation);
+        def.schemaChecksum = q.db.schema?.hash || 0;
+        q.def = def;
+        // proposal:
+        for (const command of commands) {
+            q[command.method](...command.args);
+        }
+        if (!q.def.include.stringFields.size && !q.def.references.size) {
+            includeField(q.def, '*');
+        }
+        q.queryCommands = commands;
         const b = defToBuffer(q.db, q.def);
         const buf = concatUint8Arr(b);
         let id = native.crc32(buf);

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

@@ -10,5 +10,5 @@ export declare class SubStore {
     subscribe(q: BasedDbQuery): void;
     resubscribe(q: BasedDbQuery): void;
 }
-export declare const subscribe: (q: BasedDbQuery, onData: OnData, onError?: OnError) => OnClose;
+export declare const subscribe: (q: BasedDbQuery, onData: OnData, onError: OnError) => OnClose;
 export * from './types.js';

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

@@ -1,5 +1,4 @@
 import { BasedQueryResponse } from '../BasedIterable.js';
-import { includeField } from '../query.js';
 import { registerQuery } from '../registerQuery.js';
 export class SubStore {
     listeners;
@@ -8,11 +7,7 @@ export class SubStore {
     checksum;
     len;
     subscribe(q) {
-        if (!q.def.include.stringFields.size && !q.def.references.size) {
-            includeField(q.def, '*');
-        }
-        registerQuery(q);
-        this.onClose = q.db.hooks.subscribe(q, (res) => {
+        const onData = (res) => {
             if (!this.response) {
                 this.response = new BasedQueryResponse(q.id, q.def, res, 0);
             }
@@ -29,15 +24,43 @@ export class SubStore {
                 this.len = len;
                 this.checksum = checksum;
             }
-        }, (err) => {
+        };
+        const onError = (err) => {
             for (const [, onError] of this.listeners) {
                 onError(err);
             }
-        });
+        };
+        let killed = false;
+        if (!q.db.schema) {
+            q.db.schemaIsSet().then(() => {
+                if (!killed) {
+                    try {
+                        registerQuery(q);
+                        this.onClose = q.db.hooks.subscribe(q, onData, onError);
+                    }
+                    catch (err) {
+                        onError(err);
+                    }
+                }
+            });
+            this.onClose = () => {
+                killed = true;
+            };
+        }
+        else {
+            try {
+                registerQuery(q);
+                this.onClose = q.db.hooks.subscribe(q, onData, onError);
+            }
+            catch (err) {
+                onError(err);
+                this.onClose = () => { };
+            }
+        }
     }
     resubscribe(q) {
         this.onClose();
-        q.reBuildQuery();
+        q.reset();
         this.response = null;
         this.subscribe(q);
     }

package/dist/src/client/setLocalClientSchema.d.ts

@@ -0,0 +1,3 @@
+import { DbClient } from '../index.js';
+import { DbSchema } from '../schema.js';
+export declare const setLocalClientSchema: (client: DbClient, schema: DbSchema) => DbSchema;

package/dist/src/client/setLocalClientSchema.js

@@ -0,0 +1,30 @@
+import { schemaToSelvaBuffer, updateTypeDefs } from '@based/schema/def';
+import { execCtxQueue } from './flushModify.js';
+export const setLocalClientSchema = (client, schema) => {
+    if (client.schema && client.schema.hash === schema.hash) {
+        return client.schema;
+    }
+    const { schemaTypesParsed, schemaTypesParsedById } = updateTypeDefs(schema);
+    client.schema = schema;
+    client.schemaTypesParsed = schemaTypesParsed;
+    client.schemaTypesParsedById = schemaTypesParsedById;
+    // Adds bidrectional refs on defs
+    schemaToSelvaBuffer(client.schemaTypesParsed);
+    // this has to happen before the listeners
+    if (client.modifyCtx.len > 8) {
+        console.info('Modify cancelled - schema updated');
+    }
+    // cancel modify queue
+    const resCtx = client.modifyCtx.ctx;
+    client.modifyCtx.reset();
+    execCtxQueue(resCtx, true);
+    // resubscribe
+    for (const [q, store] of client.subs) {
+        store.resubscribe(q);
+    }
+    process.nextTick(() => {
+        client.emit('schema', schema);
+    });
+    return schema;
+};
+//# sourceMappingURL=setLocalClientSchema.js.map

package/dist/src/hooks.d.ts

@@ -1,16 +1,17 @@
 import { StrictSchema } from '@based/schema';
 import { BasedDbQuery } from './client/query/BasedDbQuery.js';
-import { OnError } from './client/query/subscription/types.js';
+import { OnClose, OnData, OnError } from './client/query/subscription/types.js';
 import { DbServer } from './server/index.js';
-export declare const getDefaultHooks: (server: DbServer, subInterval?: number) => {
-    subscribe(q: BasedDbQuery, onData: (res: Uint8Array) => void, onError: OnError): () => void;
-    setSchema(schema: StrictSchema, fromStart: boolean): Promise<StrictSchema & {
-        lastId: number;
-        hash?: number;
-    }>;
+import { TransformFns } from './server/migrate/index.js';
+import { DbSchema, SchemaChecksum } from './schema.js';
+export type DbClientHooks = {
+    setSchema(schema: StrictSchema, transformFns?: TransformFns): Promise<SchemaChecksum>;
     flushModify(buf: Uint8Array): Promise<{
         offsets: Record<number, number>;
-        dbWriteTime: number;
+        dbWriteTime?: number;
     }>;
     getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
+    subscribe(q: BasedDbQuery, onData: (buf: Uint8Array) => ReturnType<OnData>, onError?: OnError): OnClose;
+    subscribeSchema(cb: (schema: DbSchema) => void): void;
 };
+export declare const getDefaultHooks: (server: DbServer, subInterval?: number) => DbClientHooks;

package/dist/src/hooks.js

@@ -32,8 +32,16 @@ export const getDefaultHooks = (server, subInterval = 200) => {
                 killed = true;
             };
         },
-        setSchema(schema, fromStart) {
-            return Promise.resolve(server.setSchema(schema, fromStart));
+        setSchema(schema) {
+            return server.setSchema(schema);
+        },
+        subscribeSchema(setSchema) {
+            if (server.schema) {
+                setSchema(server.schema);
+            }
+            server.on('schema', (schema) => {
+                setSchema(schema);
+            });
         },
         flushModify(buf) {
             const d = performance.now();

package/dist/src/index.d.ts

@@ -3,6 +3,7 @@ import { ModifyCtx } from './client/flushModify.js';
 import { DbServer } from './server/index.js';
 import { DbClient } from './client/index.js';
 import { getDefaultHooks } from './hooks.js';
+import { Emitter } from './shared/Emitter.js';
 export * from './client/modify/modify.js';
 export { compress, decompress };
 export { ModifyCtx };
@@ -16,9 +17,9 @@ export * from './client/query/query.js';
 export * from './client/query/BasedDbQuery.js';
 export * from './client/query/BasedIterable.js';
 export * from './server/save.js';
+export * from './hooks.js';
 export { getDefaultHooks };
-export declare class BasedDb {
-    #private;
+export declare class BasedDb extends Emitter {
     client: DbClient;
     server: DbServer;
     fileSystemPath: string;
@@ -36,17 +37,15 @@ export declare class BasedDb {
     delete: DbClient['delete'];
     expire: DbClient['expire'];
     query: DbClient['query'];
+    schemaIsSet: DbClient['schemaIsSet'];
     setSchema: DbClient['setSchema'];
     putSchema: DbClient['setSchema'];
     drain: DbClient['drain'];
     start: DbServer['start'];
     stop: DbServer['stop'];
     save: DbServer['save'];
-    migrateSchema: DbServer['migrateSchema'];
     isModified: DbClient['isModified'];
-    schemaIsSet: DbClient['schemaIsSet'];
     destroy(): Promise<void>;
-    wipe(): Promise<void>;
-    on: DbClient['on'];
-    off: DbClient['off'];
+    on(): any;
+    off(): any;
 }