@based/db 0.0.70 → 0.1.0

package/dist/src/client/modify/props/string.js

@@ -0,0 +1,51 @@
+import { DELETE, DELETE_TEXT_FIELD, RANGE_ERR, UPDATE, } from '../types.js';
+import { FULL_CURSOR_SIZE, PROP_CURSOR_SIZE, writePropCursor, } from '../cursor.js';
+import { reserve } from '../resize.js';
+import { ENCODER, writeUint32 } from '@based/utils';
+import { write } from '../../string.js';
+import { writeU8, writeU8Array } from '../uint.js';
+import { markString } from '../create/mark.js';
+import { validate } from '../validate.js';
+export const deleteString = (ctx, def, lang) => {
+    if (ctx.operation !== UPDATE) {
+        return;
+    }
+    if (!lang) {
+        reserve(ctx, PROP_CURSOR_SIZE + 1);
+        writePropCursor(ctx, def);
+        writeU8(ctx, DELETE);
+    }
+    else {
+        reserve(ctx, PROP_CURSOR_SIZE + 2);
+        writePropCursor(ctx, def);
+        writeU8(ctx, DELETE_TEXT_FIELD);
+        writeU8(ctx, lang);
+    }
+};
+export const writeString = (ctx, def, val, lang) => {
+    const isUint8 = val instanceof Uint8Array;
+    if (val === null || val === '' || (isUint8 && val.byteLength === 0)) {
+        deleteString(ctx, def, lang);
+        return;
+    }
+    validate(def, val);
+    let size = isUint8 ? val.byteLength : ENCODER.encode(val).byteLength + 6;
+    reserve(ctx, FULL_CURSOR_SIZE + 11 + size);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    const index = ctx.index;
+    ctx.index += 4;
+    if (isUint8) {
+        writeU8Array(ctx, val);
+    }
+    else {
+        size = write(ctx, val, ctx.index, def.compression === 0, lang);
+        if (size === null) {
+            throw RANGE_ERR;
+        }
+        ctx.index += size;
+    }
+    writeUint32(ctx.array, size, index);
+    markString(ctx, def);
+};
+//# sourceMappingURL=string.js.map

package/dist/src/client/modify/props/text.d.ts

@@ -0,0 +1,3 @@
+import { PropDef } from '@based/schema/def';
+import { Ctx } from '../Ctx.js';
+export declare const writeText: (ctx: Ctx, def: PropDef, val: any) => void;

package/dist/src/client/modify/props/text.js

@@ -0,0 +1,35 @@
+import { deleteString, writeString } from './string.js';
+import { markTextValue, markTextObj } from '../create/mark.js';
+export const writeText = (ctx, def, val) => {
+    if (val === null) {
+        deleteString(ctx, def, ctx.locale);
+        return;
+    }
+    if (typeof val === 'string' || val instanceof Uint8Array) {
+        if (!ctx.locale) {
+            throw [def, val];
+        }
+        if (!ctx.schema.separateTextSort.localeToIndex.has(ctx.locale)) {
+            throw [def, val, 'Invalid locale'];
+        }
+        writeString(ctx, def, val, ctx.locale);
+        markTextValue(ctx, def, ctx.locale, true);
+        return;
+    }
+    if (typeof val === 'object') {
+        markTextObj(ctx);
+        for (const lang in val) {
+            const langU8 = ctx.schema.separateTextSort.localeStringToIndex.get(lang);
+            if (!langU8) {
+                throw [def, val, 'Invalid locale'];
+            }
+            const text = val[lang];
+            const locale = langU8[1];
+            writeString(ctx, def, text, locale);
+            markTextValue(ctx, def, locale, false);
+        }
+        return;
+    }
+    throw [def, val];
+};
+//# sourceMappingURL=text.js.map

package/dist/src/client/modify/props/vector.d.ts

@@ -0,0 +1,3 @@
+import { Ctx } from '../Ctx.js';
+import { PropDef } from '@based/schema/def';
+export declare const writeVector: (ctx: Ctx, def: PropDef, val: any) => void;

package/dist/src/client/modify/props/vector.js

@@ -0,0 +1,30 @@
+import { deleteProp } from './delete.js';
+import { validate } from '../validate.js';
+import { PROP_CURSOR_SIZE, writePropCursor } from '../cursor.js';
+import { reserve } from '../resize.js';
+import { writePadding, writeU32, writeU8, writeU8Array } from '../uint.js';
+export const writeVector = (ctx, def, val) => {
+    if (val === null) {
+        deleteProp(ctx, def);
+        return;
+    }
+    validate(def, val);
+    if (val.byteLength === 0) {
+        deleteProp(ctx, def);
+        return;
+    }
+    reserve(ctx, PROP_CURSOR_SIZE + 9 + val.byteLength);
+    writePropCursor(ctx, def);
+    writeU8(ctx, ctx.operation);
+    let size = Math.min(val.byteLength, def.len);
+    let padding = 0;
+    if (ctx.index % 4 !== 0) {
+        padding = ctx.index % 4;
+        size -= padding;
+    }
+    writeU32(ctx, size + 4);
+    writeU8(ctx, padding);
+    writePadding(ctx, 3 - padding);
+    writeU8Array(ctx, new Uint8Array(val.buffer).subarray(0, size));
+};
+//# sourceMappingURL=vector.js.map

package/dist/src/client/modify/resize.d.ts

@@ -0,0 +1,3 @@
+import { Ctx } from './Ctx.js';
+export declare const resize: (ctx: Ctx, size: number) => void;
+export declare const reserve: (ctx: Ctx, size: number) => void;

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

@@ -0,0 +1,20 @@
+import { RANGE_ERR } from './types.js';
+export const resize = (ctx, size) => {
+    if (size > ctx.max) {
+        throw RANGE_ERR;
+    }
+    if (size > ctx.size) {
+        const avail = ctx.array.buffer.maxByteLength;
+        const affix = avail - ctx.max;
+        const required = size + affix;
+        const double = Math.max(required, ctx.size * 2);
+        const length = Math.min(avail, double);
+        // @ts-ignore
+        ctx.array.buffer.resize(length);
+        ctx.size = length - affix;
+    }
+};
+export const reserve = (ctx, size) => {
+    resize(ctx, ctx.index + size);
+};
+//# sourceMappingURL=resize.js.map

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

@@ -1,5 +1,4 @@
 import { LangName } from '@based/schema';
-import { ModifyError } from './ModifyRes.js';
 export declare const CREATE = 3;
 export declare const UPDATE = 6;
 export declare const UPDATE_PARTIAL = 5;
@@ -22,7 +21,6 @@ export declare const MOD_OPS_TO_STRING: Record<ModifyOp, 'create' | 'update'>;
 export declare const enum SIZE {
     DEFAULT_CURSOR = 11
 }
-export type ModifyErr = typeof RANGE_ERR | ModifyError | void;
 export type ModifyOpts = {
     unsafe?: boolean;
     locale?: LangName;
@@ -36,8 +34,9 @@ export declare const NOEDGE_NOINDEX_TMPID = 4;
 export declare const EDGE_NOINDEX_TMPID = 5;
 export declare const EDGE_INDEX_TMPID = 6;
 export declare const NOEDGE_INDEX_TMPID = 7;
-export declare const REF_OP_UPDATE = 1;
 export declare const REF_OP_OVERWRITE = 0;
+export declare const REF_OP_UPDATE = 1;
+export declare const REF_OP_DELETE = 2;
 export declare const REF_OP_PUT_OVERWRITE = 3;
 export declare const REF_OP_PUT_ADD = 4;
-export type REF_OP = typeof REF_OP_OVERWRITE | typeof REF_OP_UPDATE;
+export type RefOp = typeof REF_OP_OVERWRITE | typeof REF_OP_UPDATE;

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

@@ -29,8 +29,9 @@ export const NOEDGE_NOINDEX_TMPID = 4;
 export const EDGE_NOINDEX_TMPID = 5;
 export const EDGE_INDEX_TMPID = 6;
 export const NOEDGE_INDEX_TMPID = 7;
-export const REF_OP_UPDATE = 1;
 export const REF_OP_OVERWRITE = 0;
+export const REF_OP_UPDATE = 1;
+export const REF_OP_DELETE = 2;
 export const REF_OP_PUT_OVERWRITE = 3;
 export const REF_OP_PUT_ADD = 4;
 //# sourceMappingURL=types.js.map

package/dist/src/client/modify/uint.d.ts

@@ -0,0 +1,7 @@
+import { Ctx } from './Ctx.js';
+export declare const writeU64: (ctx: Ctx, val: number) => void;
+export declare const writeU32: (ctx: Ctx, val: number) => void;
+export declare const writePadding: (ctx: Ctx, padding: number) => void;
+export declare const writeU16: (ctx: Ctx, val: number) => void;
+export declare const writeU8: (ctx: Ctx, val: number) => void;
+export declare const writeU8Array: (ctx: Ctx, val: Uint8Array) => void;

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

@@ -0,0 +1,27 @@
+import { writeInt64, writeUint16, writeUint32 } from '@based/utils';
+export const writeU64 = (ctx, val) => {
+    writeInt64(ctx.array, val, ctx.index);
+    ctx.index += 8;
+};
+export const writeU32 = (ctx, val) => {
+    writeUint32(ctx.array, val, ctx.index);
+    ctx.index += 4;
+};
+export const writePadding = (ctx, padding) => {
+    while (padding--) {
+        ctx.array[ctx.index++] = 0;
+    }
+};
+export const writeU16 = (ctx, val) => {
+    writeUint16(ctx.array, val, ctx.index);
+    ctx.index += 2;
+};
+export const writeU8 = (ctx, val) => {
+    ctx.array[ctx.index] = val;
+    ctx.index += 1;
+};
+export const writeU8Array = (ctx, val) => {
+    ctx.array.set(val, ctx.index);
+    ctx.index += val.byteLength;
+};
+//# sourceMappingURL=uint.js.map

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

@@ -0,0 +1,3 @@
+import { ModifyOpts } from '../types.js';
+import { DbClient } from '../../../index.js';
+export declare function update(db: DbClient, type: string, id: number, payload: any, opts: ModifyOpts): Promise<number>;

package/dist/src/client/modify/update/index.js

@@ -0,0 +1,75 @@
+import { UPDATE, UPDATE_PARTIAL } from '../types.js';
+import { getValidSchema, validateId, validatePayload } from '../validate.js';
+import { langCodesMap } from '@based/schema';
+import { handleError } from '../error.js';
+import { Tmp } from '../Tmp.js';
+import { writeObject } from '../props/object.js';
+import { reserve } from '../resize.js';
+import { FULL_CURSOR_SIZE, PROP_CURSOR_SIZE, writeMainCursor, writeNodeCursor, writeTypeCursor, } from '../cursor.js';
+import { getByPath, writeUint32 } from '@based/utils';
+import { writeU16, writeU8 } from '../uint.js';
+import { writeFixed } from '../props/fixed.js';
+import { schedule } from '../drain.js';
+const writeUpdateTs = (ctx, payload) => {
+    if (ctx.schema.updateTs) {
+        const updateTs = Date.now();
+        for (const def of ctx.schema.updateTs) {
+            if (getByPath(payload, def.path) !== undefined) {
+                continue;
+            }
+            ctx.main.set(def, updateTs);
+        }
+    }
+};
+const writeMergeMain = (ctx) => {
+    if (ctx.main.size) {
+        reserve(ctx, PROP_CURSOR_SIZE + 5 + ctx.main.size * 4);
+        writeMainCursor(ctx);
+        writeU8(ctx, UPDATE_PARTIAL);
+        const index = ctx.index;
+        ctx.index += 4;
+        const start = ctx.index;
+        for (const [def, val] of ctx.main) {
+            writeU16(ctx, def.start);
+            writeU16(ctx, def.len);
+            writeFixed(ctx, def, val);
+        }
+        writeUint32(ctx.array, ctx.index - start, index);
+    }
+};
+const writeUpdate = (ctx, payload) => {
+    reserve(ctx, FULL_CURSOR_SIZE);
+    writeTypeCursor(ctx);
+    writeNodeCursor(ctx);
+    writeObject(ctx, ctx.schema.tree, payload);
+    writeUpdateTs(ctx, payload);
+    writeMergeMain(ctx);
+};
+export function update(db, type, id, payload, opts) {
+    const schema = getValidSchema(db, type);
+    const ctx = db.modifyCtx;
+    try {
+        validatePayload(payload);
+        validateId(id);
+        if (schema.hooks?.update) {
+            payload = schema.hooks.update(payload) || payload;
+        }
+        ctx.id = id;
+        ctx.schema = schema;
+        ctx.operation = UPDATE;
+        ctx.overwrite = opts?.overwrite;
+        ctx.locale = opts?.locale && langCodesMap.get(opts.locale);
+        ctx.start = ctx.index;
+        if (ctx.main.size) {
+            ctx.main.clear();
+        }
+        writeUpdate(ctx, payload);
+        const tmp = new Tmp(ctx, id);
+        schedule(db, ctx);
+        return tmp;
+    }
+    catch (e) {
+        return handleError(db, ctx, update, arguments, e);
+    }
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import { DbClient } from '../../../index.js';
+import { ModifyOpts } from '../types.js';
+export declare const upsert: (db: DbClient, type: string, obj: any, opts: ModifyOpts) => Promise<number>;

package/dist/src/client/modify/{upsert.js → upsert/index.js}

@@ -1,5 +1,5 @@
-import { deepMerge } from '@saulx/utils';
 import { ALIAS, isPropDef } from '@based/schema/def';
+import { deepMerge } from '@based/utils';
 const filterAliases = (obj, tree) => {
     let aliases;
     for (const key in obj) {
@@ -23,7 +23,7 @@ const filterAliases = (obj, tree) => {
     }
     return aliases;
 };
-export async function upsert(db, type, obj, opts) {
+export const upsert = (db, type, obj, opts) => {
     const tree = db.schemaTypesParsed[type].tree;
     const aliases = filterAliases(obj, tree);
     const q = db.query(type, aliases);
@@ -50,5 +50,5 @@ export async function upsert(db, type, obj, opts) {
     };
     db.upserting.set(q.id, store);
     return store.p;
-}
-//# sourceMappingURL=upsert.js.map
+};
+//# sourceMappingURL=index.js.map

package/dist/src/client/modify/validate.d.ts

@@ -0,0 +1,6 @@
+import { PropDef, PropDefEdge } from '@based/schema/def';
+import { DbClient } from '../../index.js';
+export declare const validate: (def: PropDef | PropDefEdge, val: any) => void;
+export declare const validatePayload: (payload: any) => void;
+export declare const validateId: (id: number) => void;
+export declare const getValidSchema: (db: DbClient, type: string) => import("@based/schema/def").SchemaTypeDef;

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

@@ -0,0 +1,24 @@
+import { isValidId } from '@based/schema/def';
+export const validate = (def, val) => {
+    if (!def.validation(val, def)) {
+        throw [def, val];
+    }
+};
+export const validatePayload = (payload) => {
+    if (typeof payload !== 'object' || payload === null) {
+        throw 'Invalid payload';
+    }
+};
+export const validateId = (id) => {
+    if (!isValidId(id)) {
+        throw 'Invalid id';
+    }
+};
+export const getValidSchema = (db, type) => {
+    const schema = db.schemaTypesParsed[type];
+    if (schema) {
+        return schema;
+    }
+    throw `Unknown type: ${type}. Did you mean on of: ${Object.keys(db.schemaTypesParsed).join(', ')}`;
+};
+//# sourceMappingURL=validate.js.map

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

@@ -1,10 +1,12 @@
-import { QueryDef, QueryTarget, Operator, QueryByAliasObj, LangFallback } from './query.js';
-import { BasedQueryResponse } from './BasedIterable.js';
+import { QueryDef, QueryTarget, Operator, QueryByAliasObj, LangFallback, IncludeOpts } from './query.js';
+import { BasedQueryResponse } from './BasedQueryResponse.js';
 import { Search } from './search/index.js';
 import { OnData, OnError } from './subscription/index.js';
 import { DbClient } from '../index.js';
 import { LangName } from '@based/schema';
-import { FilterAst, FilterBranchFn, FilterOpts } from './filter/types.js';
+import { FilterBranchFn, FilterOpts } from './filter/types.js';
+import { StepInput, aggFnOptions } from './aggregates/types.js';
+import { ReaderSchema } from '@based/protocol/db-read';
 export { QueryByAliasObj };
 export type SelectFn = (field: string) => BasedDbReferenceQuery;
 export type BranchInclude = (select: SelectFn) => any;
@@ -19,35 +21,36 @@ export declare class QueryBranch<T> {
     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;
     search(query: string, ...fields: Search[]): T;
     search(query: ArrayBufferView, field: string, opts?: Omit<FilterOpts, 'lowerCase'>): T;
-    groupBy(field: string): T;
+    groupBy(field: string, step?: StepInput): T;
     count(field?: string): T;
-    sum(...fields: (string | string[])[]): T;
-    cardinality(...fields: (string | string[])[]): T;
-    stddev(...fields: (string | string[])[]): T;
-    var(...fields: (string | string[])[]): T;
-    avg(...fields: (string | string[])[]): T;
-    max(...fields: (string | string[])[]): T;
-    min(...fields: (string | string[])[]): T;
+    sum(...fields: string[]): T;
+    cardinality(field: string): T;
+    stddev(...args: (string | aggFnOptions)[]): T;
+    var(...args: (string | aggFnOptions)[]): T;
+    avg(...fields: string[]): T;
+    harmonicMean(...fields: string[]): T;
+    max(...fields: string[]): T;
+    min(...fields: string[]): T;
     or(fn: FilterBranchFn): T;
     or(field: string, operator?: Operator | boolean, value?: any, opts?: FilterOpts): T;
     range(start: number, end?: number): T;
-    include(...fields: (string | BranchInclude | string[])[]): T;
+    include(...fields: (string | BranchInclude | IncludeOpts | (string | IncludeOpts)[])[]): T;
 }
 export declare class BasedDbReferenceQuery extends QueryBranch<BasedDbReferenceQuery> {
 }
 declare class GetPromise extends Promise<BasedQueryResponse> {
     toObject(): Promise<any>;
-    toJSON(): Promise<string>;
+    toJSON(replacer?: (this: any, key: string, value: any) => any, space?: string | number): Promise<string>;
     inspect(depth?: number, raw?: boolean): GetPromise;
 }
 export declare class BasedDbQuery extends QueryBranch<BasedDbQuery> {
     #private;
     skipValidation: boolean;
     target: QueryTarget;
-    constructor(db: DbClient, type: string, rawTarget?: QueryByAliasObj | number | Uint32Array | (QueryByAliasObj | number)[], skipValidation?: boolean);
+    readSchema: ReaderSchema;
+    constructor(db: DbClient, type: string, rawTarget?: QueryByAliasObj | number | Promise<number> | Uint32Array | (QueryByAliasObj | number)[], skipValidation?: boolean);
     reset(): void;
     id: number;
     get(): GetPromise;