@based/db 0.0.41 → 0.0.43

package/dist/src/client/modify/references/appendEdgeRefs.d.ts

@@ -1,4 +1,4 @@
-import { PropDefEdge } from '@based/schema/def';
-import { ModifyCtx } from '../../flushModify.js';
-import { ModifyErr } from '../types.js';
+import type { PropDefEdge } from '@based/schema/def';
+import type { ModifyCtx } from '../../flushModify.js';
+import type { ModifyErr } from '../types.js';
 export declare function appendEdgeRefs(t: PropDefEdge, ctx: ModifyCtx, value: any[]): ModifyErr;

package/dist/src/client/modify/references/appendEdgeRefs.js

@@ -1,4 +1,4 @@
-import { ModifyState, ModifyError } from '../ModifyRes.js';
+import { ModifyError, ModifyState } from '../ModifyRes.js';
 export function appendEdgeRefs(t, ctx, value) {
     for (let i = 0; i < value.length; i++) {
         let id = value[i];

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

@@ -3,3 +3,4 @@ import { AggregateType } from './types.js';
 export declare const aggregateToBuffer: (aggregates: QueryDefAggregation) => Uint8Array;
 export declare const groupBy: (def: QueryDef, field: string) => void;
 export declare const addAggregate: (type: AggregateType, def: QueryDef, fields: (string | string[])[]) => void;
+export declare const isRootCountOnly: (def: QueryDef, filterSize: number) => boolean;

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

@@ -1,4 +1,5 @@
 import { writeUint16 } from '@saulx/utils';
+import { QueryDefType } from '../types.js';
 import { UINT32 } from '@based/schema/def';
 import { aggregationFieldDoesNotExist } from '../validation.js';
 export const aggregateToBuffer = (aggregates) => {
@@ -107,4 +108,29 @@ export const addAggregate = (type, def, fields) => {
         }
     }
 };
+export const isRootCountOnly = (def, filterSize) => {
+    if (filterSize != 0) {
+        return false;
+    }
+    if (def.type !== QueryDefType.Root) {
+        return false;
+    }
+    if (def.aggregate.groupBy) {
+        return false;
+    }
+    if (def.aggregate.aggregates.size !== 1) {
+        return false;
+    }
+    if (!def.aggregate.aggregates.has(255)) {
+        return false;
+    }
+    const aggs = def.aggregate.aggregates.get(255);
+    if (aggs.length !== 1) {
+        return false;
+    }
+    if (aggs[0].type !== 2 /* AggregateType.COUNT */) {
+        return false;
+    }
+    return true;
+};
 //# sourceMappingURL=aggregation.js.map

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

@@ -4,7 +4,7 @@ import { includeToBuffer } from './include/toBuffer.js';
 import { filterToBuffer } from './query.js';
 import { searchToBuffer } from './search/index.js';
 import { ENCODER } from '@saulx/utils';
-import { aggregateToBuffer } from './aggregates/aggregation.js';
+import { aggregateToBuffer, isRootCountOnly } from './aggregates/aggregation.js';
 const byteSize = (arr) => {
     return arr.reduce((a, b) => {
         return a + b.byteLength;
@@ -33,9 +33,6 @@ export function defToBuffer(db, def) {
         edgesSize = byteSize(edges);
     }
     const size = (edges ? edgesSize + 3 : 0) + byteSize(include);
-    // ---------------------------------------
-    // move down and will handle size after store the size Var
-    // only for references | edges
     if (def.aggregate) {
         const aggregateSize = def.aggregate.size || 0;
         if (aggregateSize === 0) {
@@ -43,7 +40,9 @@ export function defToBuffer(db, def) {
         }
         const filterSize = def.filter.size || 0;
         const buf = new Uint8Array(16 + filterSize + aggregateSize);
-        buf[0] = QueryType.aggregates;
+        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;
@@ -66,8 +65,6 @@ export function defToBuffer(db, def) {
         result.push(buf);
         // ignore this for now...
         // result.push(...include)
-        // console.log('toBuffer > result: ', result)
-        // later this has to be a branch
         return result;
     }
     if (def.type === QueryDefType.Root) {

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

@@ -12,7 +12,8 @@ export declare enum QueryType {
     ids = 1,
     default = 2,
     alias = 3,
-    aggregates = 4
+    aggregates = 4,
+    aggregatesCountType = 5
 }
 declare enum QueryDefType {
     Edge = 1,

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

@@ -5,6 +5,7 @@ export var QueryType;
     QueryType[QueryType["default"] = 2] = "default";
     QueryType[QueryType["alias"] = 3] = "alias";
     QueryType[QueryType["aggregates"] = 4] = "aggregates";
+    QueryType[QueryType["aggregatesCountType"] = 5] = "aggregatesCountType";
 })(QueryType || (QueryType = {}));
 var QueryDefType;
 (function (QueryDefType) {

package/dist/src/index.d.ts

@@ -8,6 +8,7 @@ export { ModifyCtx };
 export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
+export { default as createHash } from './server/dbHash.js';
 export * from './client/query/serialize.js';
 export * from './utils.js';
 export * from './client/query/query.js';

package/dist/src/index.js

@@ -11,6 +11,7 @@ export { ModifyCtx }; // TODO move this somewhere
 export { DbClient, DbServer };
 export { xxHash64 } from './client/xxHash64.js';
 export { crc32 } from './client/crc32.js';
+export { default as createHash } from './server/dbHash.js';
 export * from './client/query/serialize.js';
 export * from './utils.js';
 export * from './client/query/query.js';

package/dist/src/server/index.d.ts

@@ -30,6 +30,7 @@ export declare class DbServer {
     dbCtxExternal: any;
     schema: StrictSchema & {
         lastId: number;
+        hash?: number;
     };
     migrating: number;
     schemaTypesParsed: SchemaTypesParsed;
@@ -88,12 +89,15 @@ export declare class DbServer {
     getSortIndex(typeId: number, field: number, start: number, lang: number): SortIndex;
     migrateSchema(schema: StrictSchema, transform?: Record<string, (node: Record<string, any>) => Record<string, any> | [string, Record<string, any>]>): Promise<StrictSchema & {
         lastId: number;
+        hash?: number;
     }>;
     createSortIndexBuffer(typeId: number, field: number, start: number, lang: number): SortIndex;
     setSchema(strictSchema: StrictSchema, fromStart?: boolean, transformFns?: TransformFns): (StrictSchema & {
         lastId: number;
+        hash?: number;
     }) | Promise<StrictSchema & {
         lastId: number;
+        hash?: number;
     }>;
     modify(buf: Uint8Array): Record<number, number>;
     addToQueryQueue(resolve: any, buf: any): void;

package/dist/src/server/index.js

@@ -12,6 +12,7 @@ import { fileURLToPath } from 'node:url';
 import { setTimeout } from 'node:timers/promises';
 import { migrate } from './migrate/index.js';
 import { debugServer, schemaLooseEqual } from '../utils.js';
+import { hash } from '@saulx/hash';
 export const SCHEMA_FILE = 'schema.json';
 export const WRITELOG_FILE = 'writelog.json';
 const __filename = fileURLToPath(import.meta.url);
@@ -339,6 +340,8 @@ export class DbServer {
             }
         }
         updateTypeDefs(this.schema, this.schemaTypesParsed, this.schemaTypesParsedById);
+        const { hash: _, ...schemaWithoutHash } = this.schema;
+        this.schema.hash = hash(schemaWithoutHash);
         if (!fromStart) {
             writeFile(join(this.fileSystemPath, SCHEMA_FILE), JSON.stringify(this.schema)).catch((err) => console.error('!!!', SCHEMA_FILE, err));
             let types = Object.keys(this.schemaTypesParsed);

package/dist/src/server/start.js

@@ -47,7 +47,7 @@ export async function start(db, opts) {
         const schema = await readFile(join(path, SCHEMA_FILE));
         if (schema) {
             // Prop need to not call setting in selva
-            db.setSchema(JSON.parse(schema.toString()), true);
+            await db.setSchema(JSON.parse(schema.toString()), true);
         }
     }
     catch (err) {

package/dist/src/utils.js

@@ -43,7 +43,7 @@ export const debugMode = (target, getInfo = null) => {
     }
 };
 export const debugServer = (server) => debugMode(server, () => `p: ${server.processingQueries} m: ${server.modifyQueue.length} q: ${server.queryQueue.size}`);
-const exclude = new Set(['id', 'lastId']);
+const exclude = new Set(['id', 'lastId', 'hash']);
 export const schemaLooseEqual = (a, b, key) => {
     if (a === b) {
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/db",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "license": "MIT",
   "type": "module",
   "main": "./dist/src/index.js",