@based/db 0.0.52 → 0.0.56

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

@@ -32,3 +32,4 @@ export declare class ModifyCtx {
 export declare const execCtxQueue: (resCtx: ModifyCtx["ctx"], error?: boolean) => void;
 export declare const flushBuffer: (db: DbClient) => Promise<void>;
 export declare const startDrain: (db: DbClient) => void;
+export declare const makeFlushIsReady: (dbClient: DbClient) => void;

package/dist/src/client/flushModify.js

@@ -178,4 +178,12 @@ export const startDrain = (db) => {
         }, db.flushTime);
     }
 };
+export const makeFlushIsReady = (dbClient) => {
+    dbClient.flushIsReady = new Promise((resolve) => {
+        dbClient.flushReady = () => {
+            resolve();
+            makeFlushIsReady(dbClient);
+        };
+    });
+};
 //# sourceMappingURL=flushModify.js.map

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

@@ -1,40 +1,27 @@
-import { Schema, StrictSchema } from '@based/schema';
+import { Schema } from '@based/schema';
 import { CreateObj } from './modify/create.js';
-import { SchemaTypeDef } from '@based/schema/def';
 import { ModifyCtx } from './flushModify.js';
 import { BasedDbQuery, QueryByAliasObj } from './query/BasedDbQuery.js';
 import { ModifyRes } from './modify/ModifyRes.js';
-import { DbServer } from '../server/index.js';
 import { TransformFns } from '../server/migrate/index.js';
 import { ModifyOpts } from './modify/types.js';
-import { OnClose, OnData, OnError } from './query/subscription/types.js';
 import { SubStore } from './query/subscription/index.js';
-export type DbClientHooks = {
-    setSchema(schema: StrictSchema, fromStart?: boolean, transformFns?: TransformFns): Promise<DbServer['schema']>;
-    flushModify(buf: Uint8Array): Promise<{
-        offsets: Record<number, number>;
-        dbWriteTime?: number;
-    }>;
-    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
-    subscribe(q: BasedDbQuery, onData: (buf: Uint8Array) => ReturnType<OnData>, onError?: OnError): OnClose;
-};
+import { DbShared } from '../shared/DbBase.js';
+import { DbClientHooks } from '../hooks.js';
+import { SchemaChecksum } from '../schema.js';
 type DbClientOpts = {
     hooks: DbClientHooks;
     maxModifySize?: number;
     flushTime?: number;
     debug?: boolean;
 };
-type DbClientSchema = DbServer['schema'];
-export declare class DbClient {
+export declare class DbClient extends DbShared {
     constructor({ hooks, maxModifySize, flushTime, debug, }: DbClientOpts);
     subs: Map<BasedDbQuery, SubStore>;
+    hooks: DbClientHooks;
     flushTime: number;
     flushReady: () => void;
     flushIsReady: Promise<void>;
-    hooks: DbClientHooks;
-    schema: DbClientSchema;
-    schemaTypesParsed: Record<string, SchemaTypeDef>;
-    schemaTypesParsedById: Record<number, SchemaTypeDef>;
     writeTime: number;
     isDraining: boolean;
     modifyCtx: ModifyCtx;
@@ -43,13 +30,8 @@ export declare class DbClient {
         o: Record<string, any>;
         p: Promise<number | ModifyRes>;
     }>;
-    schemaProcessing: number;
-    schemaPromise: Promise<DbServer['schema']>;
-    setSchema(schema: Schema, fromStart?: boolean, transformFns?: TransformFns): Promise<StrictSchema>;
-    putLocalSchema(schema: DbServer['schema']): StrictSchema & {
-        lastId: number;
-        hash?: number;
-    };
+    schemaIsSet(): Promise<void>;
+    setSchema(schema: Schema, transformFns?: TransformFns): Promise<SchemaChecksum>;
     create(type: string, obj?: CreateObj, opts?: ModifyOpts): ModifyRes;
     copy(type: string, target: number | ModifyRes, objOrTransformFn?: Record<string, any> | ((item: Record<string, any>) => Promise<any>)): Promise<ModifyRes>;
     query(type: string, id?: number | ModifyRes | (number | ModifyRes)[] | QueryByAliasObj | QueryByAliasObj[] | Uint32Array): BasedDbQuery;
@@ -66,11 +48,5 @@ export declare class DbClient {
     stop(): void;
     drain(): Promise<number>;
     isModified(): Promise<void>;
-    schemaIsSet(): Promise<true>;
-    listeners?: {
-        schema?: Set<(schema: DbClientSchema) => void>;
-    };
-    on(event: 'schema', cb: (schema: DbClientSchema) => void): void;
-    off(event: 'schema', cb: (schema: DbClientSchema) => void): void;
 }
 export {};

package/dist/src/client/index.js

@@ -1,27 +1,18 @@
 import { parse } from '@based/schema';
 import { create } from './modify/create.js';
-import { updateTypeDefs, schemaToSelvaBuffer, } from '@based/schema/def';
-import { execCtxQueue, flushBuffer, ModifyCtx, startDrain, } from './flushModify.js';
+import { flushBuffer, makeFlushIsReady, ModifyCtx, startDrain, } from './flushModify.js';
 import { BasedDbQuery } from './query/BasedDbQuery.js';
 import { ModifyState } from './modify/ModifyRes.js';
 import { upsert } from './modify/upsert.js';
 import { update } from './modify/update.js';
 import { deleteFn } from './modify/delete.js';
-import { wait } from '@saulx/utils';
-import { hash } from '@saulx/hash';
 import { expire } from './modify/expire.js';
 import { debugMode } from '../utils.js';
-import { parseSchema, schemaLooseEqual } from '../schema.js';
-const makeFlushIsReady = (dbClient) => {
-    dbClient.flushIsReady = new Promise((resolve) => {
-        dbClient.flushReady = () => {
-            resolve();
-            makeFlushIsReady(dbClient);
-        };
-    });
-};
-export class DbClient {
+import { DbShared } from '../shared/DbBase.js';
+import { setLocalClientSchema } from './setLocalClientSchema.js';
+export class DbClient extends DbShared {
     constructor({ hooks, maxModifySize = 100 * 1e3 * 1e3, flushTime = 0, debug, }) {
+        super();
         this.hooks = hooks;
         this.maxModifySize = maxModifySize;
         this.modifyCtx = new ModifyCtx(this);
@@ -30,68 +21,35 @@ export class DbClient {
         if (debug) {
             debugMode(this);
         }
+        this.hooks.subscribeSchema((schema) => {
+            setLocalClientSchema(this, schema);
+        });
     }
     subs = new Map();
+    hooks;
+    // modify
     flushTime;
     flushReady;
     flushIsReady;
-    hooks;
-    schema;
-    schemaTypesParsed = {};
-    schemaTypesParsedById = {};
-    // modify
     writeTime = 0;
     isDraining = false;
     modifyCtx;
     maxModifySize;
     upserting = new Map();
-    schemaProcessing;
-    schemaPromise;
-    async setSchema(schema, fromStart, transformFns) {
-        const strictSchema = fromStart ? schema : parse(schema).schema;
-        const parsedSchema = parseSchema(strictSchema);
-        // this one excludes all the ids
-        if (schemaLooseEqual(parsedSchema, this.schema)) {
-            return this.schema;
-        }
-        // drain current things
-        await this.drain();
-        const checksum = hash(strictSchema);
-        if (checksum !== this.schemaProcessing) {
-            this.schemaProcessing = checksum;
-            this.schemaPromise = this.hooks.setSchema(strictSchema, fromStart, transformFns);
+    async schemaIsSet() {
+        if (!this.schema) {
+            await this.once('schema');
         }
-        const remoteSchema = await this.schemaPromise;
-        this.schemaProcessing = null;
-        this.schemaPromise = null;
-        return this.putLocalSchema(remoteSchema);
     }
-    putLocalSchema(schema) {
-        if (this.schema && this.schema.hash === schema.hash) {
-            return this.schema;
-        }
-        this.schema = schema;
-        updateTypeDefs(this.schema, this.schemaTypesParsed, this.schemaTypesParsedById);
-        // Adds bidrectional refs on defs
-        schemaToSelvaBuffer(this.schemaTypesParsed);
-        // this has to happen before the listeners
-        if (this.modifyCtx.len > 8) {
-            console.info('Modify cancelled - schema updated');
-        }
-        // cancel modify queue
-        const resCtx = this.modifyCtx.ctx;
-        this.modifyCtx.reset();
-        execCtxQueue(resCtx, true);
-        // resubscribe
-        for (const [q, store] of this.subs) {
-            store.resubscribe(q);
-        }
-        if (this.listeners?.schema) {
-            for (const cb of this.listeners.schema) {
-                cb(this.schema);
-            }
+    async setSchema(schema, transformFns) {
+        const strictSchema = parse(schema).schema;
+        await this.drain();
+        const schemaChecksum = await this.hooks.setSchema(strictSchema, transformFns);
+        if (schemaChecksum !== this.schema?.hash) {
+            await this.once('schema');
+            return this.schema.hash;
         }
-        return this.schema;
+        return schemaChecksum;
     }
     create(type, obj = {}, opts) {
         return create(this, type, obj, opts);
@@ -189,6 +147,7 @@ export class DbClient {
     }
     destroy() {
         this.stop();
+        delete this.listeners;
         this.modifyCtx.db = null; // Make sure we don't have a circular ref and leak mem
     }
     stop() {
@@ -215,26 +174,5 @@ export class DbClient {
         await this.flushIsReady;
         return;
     }
-    async schemaIsSet() {
-        if (this.schema) {
-            return true;
-        }
-        if (this.schemaPromise) {
-            await this.schemaPromise;
-        }
-        else {
-            await wait(12);
-        }
-        return this.schemaIsSet();
-    }
-    listeners;
-    on(event, cb) {
-        this.listeners ??= {};
-        this.listeners[event] ??= new Set();
-        this.listeners[event].add(cb);
-    }
-    off(event, cb) {
-        this.listeners?.[event]?.delete(cb);
-    }
 }
 //# sourceMappingURL=index.js.map

package/dist/src/client/modify/ModifyRes.js

@@ -1,5 +1,5 @@
 import { isPropDef, REVERSE_TYPE_INDEX_MAP, } from '@based/schema/def';
-import { langCodesMap } from '@based/schema';
+import { isValidId, langCodesMap } from '@based/schema';
 const MAGIC_KEY = Math.random().toString(36).substring(2);
 const MAGIC_REG = RegExp(`("${MAGIC_KEY}|${MAGIC_KEY}")`, 'g');
 const walk = (val) => {
@@ -43,6 +43,9 @@ export class ModifyError extends Error {
 }
 export class ModifyState {
     constructor(typeId, tmpId, db, opts, update = false) {
+        if (!isValidId(tmpId)) {
+            throw new Error('Invalid id passed to modify');
+        }
         this.tmpId = tmpId;
         this.#typeId = typeId;
         this.#ctx = db.modifyCtx.ctx;

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

@@ -4,6 +4,9 @@ import { DELETE, RANGE_ERR, EDGE_NOINDEX_TMPID, NOEDGE_NOINDEX_TMPID, EDGE_NOIND
 import { writeEdges } from './edge.js';
 import { dbUpdateFromUpsert } from './references.js';
 function writeRef(id, ctx, schema, def, parentId, modifyOp, hasEdges, isTmpId) {
+    if (!def.validation(id, def)) {
+        return new ModifyError(def, id);
+    }
     if (ctx.len + 16 > ctx.max) {
         return RANGE_ERR;
     }

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

@@ -16,7 +16,7 @@ export declare class QueryBranch<T> {
     db: DbClient;
     def: QueryDef;
     queryCommands: QueryCommand[];
-    constructor(db: DbClient, def: QueryDef);
+    constructor(db: DbClient, def?: QueryDef);
     sort(field: string, order?: 'asc' | 'desc'): T;
     filter<O extends Operator>(field: string, operator?: O | boolean, value?: any, opts?: FilterOpts<O>): T;
     filterBatch(f: FilterAst): this;
@@ -42,7 +42,7 @@ export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     skipValidation: boolean;
     target: QueryTarget;
     constructor(db: DbClient, type: string, rawTarget?: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[], skipValidation?: boolean);
-    reBuildQuery(): void;
+    reset(): void;
     id: number;
     get(): GetPromise;
     buffer: Uint8Array;
@@ -50,5 +50,4 @@ export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     locale(locale: LangName): this;
     subscribe(onData: OnData, onError?: OnError): OnClose;
     _getSync(dbCtxExternal: any): BasedQueryResponse;
-    toBuffer(): Uint8Array;
 }