@based/db 0.0.70 → 0.1.0

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

@@ -0,0 +1,3 @@
+import { IncludeOpts } from '../types.js';
+import { BranchInclude, QueryBranch } from '../BasedDbQuery.js';
+export declare const include: (query: QueryBranch<any>, fields: (string | BranchInclude | IncludeOpts | (string | IncludeOpts)[])[]) => void;

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

@@ -0,0 +1,58 @@
+import { QueryBranch } from '../BasedDbQuery.js';
+import { includeField } from './props.js';
+import { REFERENCE, REFERENCES } from '@based/schema/def';
+import { createOrGetEdgeRefQueryDef, createOrGetRefQueryDef } from './utils.js';
+export const include = (query, fields) => {
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        const opts = typeof fields[i + 1] === 'object' && typeof fields[i + 1] !== 'function'
+            ? fields[i + 1]
+            : undefined;
+        if (opts) {
+            i++;
+        }
+        if (typeof f === 'string') {
+            includeField(query.def, { field: f, opts });
+        }
+        else if (typeof f === 'function') {
+            f((field) => {
+                if (field[0] == '$') {
+                    // @ts-ignore
+                    const prop = query.def.target?.propDef?.edges[field];
+                    if (prop &&
+                        (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
+                        const refDef = createOrGetEdgeRefQueryDef(query.db, query.def, prop);
+                        // @ts-ignore
+                        return new QueryBranch(query.db, refDef);
+                    }
+                    throw new Error(`No edge reference or edge references field named "${field}"`);
+                }
+                else {
+                    const prop = field[0] == '$'
+                        ? // @ts-ignore
+                            query.def.target?.propDef?.edges[field]
+                        : query.def.props[field];
+                    if (prop &&
+                        (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES)) {
+                        const refDef = createOrGetRefQueryDef(query.db, query.def, prop);
+                        // @ts-ignore
+                        return new QueryBranch(query.db, refDef);
+                    }
+                    throw new Error(`No reference or references field named "${field}"`);
+                }
+            });
+        }
+        else if (Array.isArray(f)) {
+            if (f.length === 0) {
+                includeField(query.def, { field: 'id', opts });
+            }
+            else {
+                include(query, f);
+            }
+        }
+        else if (f !== undefined) {
+            throw new Error('Invalid include statement: expected props, refs and edges (string or array) or function');
+        }
+    }
+};
+//# sourceMappingURL=include.js.map

package/dist/src/client/query/include/props.d.ts

@@ -1,8 +1,8 @@
 import { PropDef, PropDefEdge } from '@based/schema/def';
-import { QueryDef } from '../types.js';
-export declare const getAll: (props: QueryDef["props"]) => string[];
-export declare const getAllRefs: (props: QueryDef["props"], affix?: string) => string[];
-export declare const includeField: (def: QueryDef, field: string) => void;
-export declare const includeFields: (def: QueryDef, fields: string[]) => void;
-export declare const includeAllProps: (def: QueryDef) => void;
-export declare const includeProp: (def: QueryDef, prop: PropDef | PropDefEdge) => boolean;
+import { IncludeField, IncludeOpts, QueryDef } from '../types.js';
+export declare const getAll: (props: QueryDef["props"], opts?: IncludeOpts) => IncludeField[];
+export declare const getAllRefs: (props: QueryDef["props"], affix?: string, opts?: IncludeOpts) => IncludeField[];
+export declare const includeField: (def: QueryDef, include: IncludeField) => void;
+export declare const includeFields: (def: QueryDef, fields: IncludeField[]) => void;
+export declare const includeAllProps: (def: QueryDef, opts?: IncludeOpts) => void;
+export declare const includeProp: (def: QueryDef, prop: PropDef | PropDefEdge, opts?: IncludeOpts) => boolean;

package/dist/src/client/query/include/props.js

@@ -1,53 +1,54 @@
 import { REFERENCE, REFERENCES, TEXT, } from '@based/schema/def';
 import { QueryDefType } from '../types.js';
-export const getAll = (props) => {
+export const getAll = (props, opts) => {
     const fields = [];
     for (const key in props) {
         const prop = props[key];
         if (prop.typeIndex !== REFERENCE && prop.typeIndex !== REFERENCES) {
-            fields.push(prop.path.join('.'));
+            fields.push({ field: prop.path.join('.'), opts });
         }
     }
     return fields;
 };
-export const getAllRefs = (props, affix = '') => {
+export const getAllRefs = (props, affix = '', opts) => {
     const fields = [];
     for (const key in props) {
         const prop = props[key];
         if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
             const refPath = prop.path.join('.') + affix;
-            fields.push(refPath);
+            fields.push({ field: refPath, opts });
             if (prop.edges) {
                 for (const edge in prop.edges) {
-                    fields.push(refPath + '.' + edge);
+                    fields.push({ field: refPath + '.' + edge, opts });
                 }
             }
         }
     }
     return fields;
 };
-export const includeField = (def, field) => {
+export const includeField = (def, include) => {
+    const { field, opts } = include;
     if (field === '*') {
         if (def.type === QueryDefType.Reference ||
             def.type === QueryDefType.References) {
             const fields = [];
             if (def.target.propDef.edges) {
                 for (const edge in def.target.propDef.edges) {
-                    fields.push(edge);
+                    fields.push({ field: edge, opts });
                 }
             }
             includeFields(def, fields);
         }
-        includeFields(def, getAll(def.props));
+        includeFields(def, getAll(def.props, opts));
     }
     else if (field === '**') {
-        includeFields(def, getAllRefs(def.props));
+        includeFields(def, getAllRefs(def.props, '', opts));
     }
     else if (field.startsWith('**.')) {
-        includeFields(def, getAllRefs(def.props, field.substring(2)));
+        includeFields(def, getAllRefs(def.props, field.substring(2), opts));
     }
     else {
-        def.include.stringFields.add(field);
+        def.include.stringFields.set(include.field, include);
     }
 };
 export const includeFields = (def, fields) => {
@@ -55,27 +56,31 @@ export const includeFields = (def, fields) => {
         includeField(def, field);
     }
 };
-export const includeAllProps = (def) => {
+export const includeAllProps = (def, opts) => {
     for (const key in def.props) {
         const prop = def.props[key];
         if (prop.typeIndex !== REFERENCE && prop.typeIndex !== REFERENCES) {
-            includeProp(def, prop);
+            includeProp(def, prop, opts);
         }
     }
 };
-export const includeProp = (def, prop) => {
+export const includeProp = (def, prop, opts) => {
     if (!prop || prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
         return false;
     }
     if (prop.typeIndex === TEXT) {
-        if (!def.include.langTextFields.has(prop.prop)) {
-            def.include.langTextFields.set(prop.prop, {
+        if (!def.include.props.has(prop.prop)) {
+            def.include.props.set(prop.prop, {
                 def: prop,
-                codes: new Set(),
-                fallBacks: [],
+                opts: {
+                    codes: new Set(),
+                    fallBacks: [],
+                    ...opts,
+                    localeFromDef: def.lang.lang,
+                },
             });
         }
-        const langs = def.include.langTextFields.get(prop.prop);
+        const langs = def.include.props.get(prop.prop).opts;
         if (def.lang.fallback.length > 0) {
             for (const fallback of def.lang.fallback) {
                 if (!langs.fallBacks.includes(fallback)) {
@@ -91,11 +96,11 @@ export const includeProp = (def, prop) => {
     }
     else {
         if (prop.separate) {
-            def.include.props.set(prop.prop, prop);
+            def.include.props.set(prop.prop, { def: prop, opts });
         }
         else {
             def.include.main.len += prop.len;
-            def.include.main.include[prop.start] = [0, prop];
+            def.include.main.include[prop.start] = [0, prop, opts];
             return true;
         }
     }

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

@@ -0,0 +1,188 @@
+import { MICRO_BUFFER, STRING, TEXT, JSON } from '@based/schema/def';
+import { QueryDefType } from '../types.js';
+import { walkDefs } from './walk.js';
+import { langCodesMap } from '@based/schema';
+import { writeUint32 } from '@based/utils';
+import { getEnd } from './utils.js';
+const EMPTY_BUFFER = new Uint8Array(0);
+export const includeToBuffer = (db, def) => {
+    const result = [];
+    if (!def.include.stringFields.size &&
+        !def.include.props.size &&
+        !def.references.size &&
+        !def.include.main.len) {
+        return result;
+    }
+    let mainBuffer;
+    if (def.include.stringFields) {
+        for (const [field, include] of def.include.stringFields.entries()) {
+            walkDefs(db, def, { field, opts: include.opts });
+        }
+    }
+    if (def.include.main.len > 0) {
+        const len = def.type === QueryDefType.Edge
+            ? def.target.ref.edgeMainLen
+            : def.schema.mainLen;
+        if (def.include.main.len === len) {
+            // GET ALL MAIN FIELDS
+            mainBuffer = EMPTY_BUFFER;
+            let i = 2;
+            for (const key in def.include.main.include) {
+                const v = def.include.main.include[key];
+                v[0] = v[1].start;
+                i += 4;
+            }
+        }
+        else {
+            // GET SOME MAIN FIELDS
+            const size = Object.keys(def.include.main.include).length;
+            mainBuffer = new Uint8Array(size * 4 + 2);
+            mainBuffer[0] = def.include.main.len;
+            mainBuffer[1] = def.include.main.len >>> 8;
+            let i = 2;
+            let m = 0;
+            for (const key in def.include.main.include) {
+                const v = def.include.main.include[key];
+                mainBuffer[i] = v[1].start;
+                mainBuffer[i + 1] = v[1].start >>> 8;
+                const len = v[1].len;
+                v[0] = m;
+                mainBuffer[i + 2] = len;
+                mainBuffer[i + 3] = len >>> 8;
+                i += 4;
+                m += len;
+            }
+        }
+    }
+    const propSize = def.include.props.size ?? 0;
+    if (mainBuffer) {
+        if (mainBuffer.byteLength !== 0) {
+            const buf = new Uint8Array(5);
+            buf[0] = 7 /* includeOp.PARTIAL */;
+            buf[1] = 0; // field name 0
+            buf[2] = MICRO_BUFFER;
+            buf[3] = mainBuffer.byteLength;
+            buf[4] = mainBuffer.byteLength >>> 8;
+            result.push(buf, mainBuffer);
+        }
+        else {
+            const buf = new Uint8Array(4);
+            buf[0] = 1 /* includeOp.DEFAULT */;
+            buf[1] = 0; // field name 0
+            buf[2] = MICRO_BUFFER;
+            buf[3] = 0; // opts len
+            result.push(buf);
+        }
+    }
+    if (propSize) {
+        for (const [prop, propDef] of def.include.props.entries()) {
+            if (propDef.opts?.meta) {
+                if (propDef.opts.codes) {
+                    if (propDef.opts.codes.has(0)) {
+                        // TODO use locales for 0 make this NICE
+                        for (const code in def.schema.locales) {
+                            const buf = new Uint8Array(4);
+                            buf[0] = 6 /* includeOp.META */;
+                            buf[1] = prop;
+                            buf[2] = propDef.def.typeIndex;
+                            buf[3] = langCodesMap.get(code);
+                            result.push(buf);
+                        }
+                    }
+                    else {
+                        for (const code of propDef.opts.codes) {
+                            const buf = new Uint8Array(4);
+                            buf[0] = 6 /* includeOp.META */;
+                            buf[1] = prop;
+                            buf[2] = propDef.def.typeIndex;
+                            buf[3] = code;
+                            result.push(buf);
+                        }
+                    }
+                }
+                else {
+                    const buf = new Uint8Array(4);
+                    buf[0] = 6 /* includeOp.META */;
+                    buf[1] = prop;
+                    buf[2] = propDef.def.typeIndex;
+                    buf[3] = 0;
+                    result.push(buf);
+                }
+            }
+            if (propDef.opts?.meta !== 'only') {
+                const hasEnd = propDef.opts?.end;
+                const t = propDef.def.typeIndex;
+                if (t === TEXT) {
+                    const codes = propDef.opts.codes;
+                    if (codes.has(0)) {
+                        const b = new Uint8Array(hasEnd ? 12 : 4);
+                        b[0] = 1 /* includeOp.DEFAULT */;
+                        b[1] = prop;
+                        b[2] = propDef.def.typeIndex;
+                        if (hasEnd) {
+                            b[3] = 8; // opts len
+                            b[4] = 0; // lang code
+                            b[5] = 0; // fallbackSize
+                            b[6] = 1; // has end
+                            b[7] = propDef.opts?.bytes ? 0 : 1; // is string
+                            writeUint32(b, getEnd(propDef.opts), 8);
+                        }
+                        else {
+                            b[3] = 0; // opts len
+                        }
+                        result.push(b);
+                    }
+                    else {
+                        for (const code of codes) {
+                            const fallBackSize = propDef.opts.fallBacks.length;
+                            const endCode = getEnd(propDef.opts, code);
+                            const b = new Uint8Array(7 + (endCode ? 5 : 0) + fallBackSize);
+                            b[0] = 1 /* includeOp.DEFAULT */;
+                            b[1] = prop;
+                            b[2] = propDef.def.typeIndex;
+                            let i = 0;
+                            if (endCode) {
+                                b[3] = fallBackSize + 8; // opts
+                                b[4] = code; // say if there is a end option
+                                b[5] = fallBackSize;
+                                b[6] = 1; // has end
+                                b[7] = propDef.opts?.bytes ? 0 : 1; // is string use chars (can be optional)
+                                writeUint32(b, endCode, 8);
+                                i = 11;
+                            }
+                            else {
+                                b[3] = fallBackSize + 3; // opts
+                                b[4] = code; // say if there is a end option
+                                b[5] = fallBackSize;
+                                b[6] = 0; // no end
+                                i = 7;
+                            }
+                            for (const fallback of propDef.opts.fallBacks) {
+                                b[i] = fallback;
+                                i++;
+                            }
+                            result.push(b);
+                        }
+                    }
+                }
+                else {
+                    const buf = new Uint8Array(hasEnd ? 9 : 4);
+                    buf[0] = 1 /* includeOp.DEFAULT */;
+                    buf[1] = prop;
+                    buf[2] = propDef.def.typeIndex;
+                    if (hasEnd) {
+                        buf[3] = 5; // opts len
+                        buf[4] = propDef.opts?.bytes || (t !== JSON && t !== STRING) ? 0 : 1;
+                        writeUint32(buf, getEnd(propDef.opts), 5);
+                    }
+                    else {
+                        buf[3] = 0; // opts len
+                    }
+                    result.push(buf);
+                }
+            }
+        }
+    }
+    return result;
+};
+//# sourceMappingURL=toByteCode.js.map

package/dist/src/client/query/include/utils.d.ts

@@ -1,6 +1,8 @@
 import { PropDef, PropDefEdge, SchemaPropTree } from '@based/schema/def';
 import { DbClient } from '../../index.js';
-import { QueryDef } from '../types.js';
+import { IncludeOpts, QueryDef } from '../types.js';
+import { LangCode } from '@based/schema';
 export declare const getAllFieldFromObject: (tree: SchemaPropTree | PropDef, arr?: string[]) => string[];
 export declare const createOrGetRefQueryDef: (db: DbClient, def: QueryDef, t: PropDef | PropDefEdge) => QueryDef;
 export declare const createOrGetEdgeRefQueryDef: (db: DbClient, def: QueryDef, t: PropDefEdge) => QueryDef;
+export declare const getEnd: (opts?: IncludeOpts, lang?: LangCode) => number;

package/dist/src/client/query/include/utils.js

@@ -1,6 +1,7 @@
 import { REFERENCE, } from '@based/schema/def';
 import { createQueryDef } from '../queryDef.js';
 import { QueryDefType } from '../types.js';
+import { inverseLangMap } from '@based/schema';
 export const getAllFieldFromObject = (tree, arr = []) => {
     for (const key in tree) {
         const leaf = tree[key];
@@ -39,4 +40,16 @@ export const createOrGetEdgeRefQueryDef = (db, def, t) => {
     const refDef = createOrGetRefQueryDef(db, def.edges, t);
     return refDef;
 };
+export const getEnd = (opts, lang) => {
+    if (!opts || !opts.end) {
+        return 0;
+    }
+    if (typeof opts.end === 'object') {
+        if (lang) {
+            return opts.end[inverseLangMap.get(lang)] ?? opts.end[0] ?? undefined;
+        }
+        return opts.end[0] ?? undefined;
+    }
+    return opts.end;
+};
 //# sourceMappingURL=utils.js.map

package/dist/src/client/query/include/walk.d.ts

@@ -1,3 +1,3 @@
-import { QueryDef } from '../types.js';
+import { IncludeField, QueryDef } from '../types.js';
 import { DbClient } from '../../index.js';
-export declare const walkDefs: (db: DbClient, def: QueryDef, f: string) => void;
+export declare const walkDefs: (db: DbClient, def: QueryDef, include: IncludeField) => void;

package/dist/src/client/query/include/walk.js

@@ -5,13 +5,13 @@ import { getAllFieldFromObject, createOrGetRefQueryDef } from './utils.js';
 import { includeProp, includeAllProps, includeField } from './props.js';
 import { langCodesMap } from '@based/schema';
 import { includeDoesNotExist, includeLangDoesNotExist } from '../validation.js';
-export const walkDefs = (db, def, f) => {
-    const prop = def.props[f];
-    const path = f.split('.');
+export const walkDefs = (db, def, include) => {
+    const prop = def.props[include.field];
+    const path = include.field.split('.');
     if (!prop) {
         let t = def.schema.tree;
         for (let i = 0; i < path.length; i++) {
-            const p = path[i];
+            let p = path[i];
             if (isRefDef(def) && p[0] == '$') {
                 if (!def.edges) {
                     def.edges = createQueryDef(db, QueryDefType.Edge, {
@@ -20,6 +20,10 @@ export const walkDefs = (db, def, f) => {
                     def.edges.lang = def.lang;
                 }
                 const edgeProp = def.edges.props[p];
+                if (!edgeProp) {
+                    includeDoesNotExist(def, include.field);
+                    return;
+                }
                 if (edgeProp.typeIndex === REFERENCE ||
                     edgeProp.typeIndex === REFERENCES) {
                     const refDef = createOrGetRefQueryDef(db, def.edges, edgeProp);
@@ -28,22 +32,22 @@ export const walkDefs = (db, def, f) => {
                     }
                     else {
                         const f = path.slice(i + 1).join('.');
-                        if (!includeProp(refDef, refDef.props[f])) {
-                            includeField(refDef, f);
+                        if (!includeProp(refDef, refDef.props[f], include.opts)) {
+                            includeField(refDef, { field: f, opts: include.opts });
                         }
                         return;
                     }
                 }
                 else {
-                    // use include here
-                    includeProp(def.edges, edgeProp);
+                    // add text for edges
+                    includeProp(def.edges, edgeProp, include.opts);
                 }
                 return;
             }
             t = t[p];
             if (!t) {
-                if (f != 'id') {
-                    includeDoesNotExist(def, f);
+                if (include.field != 'id') {
+                    includeDoesNotExist(def, include.field);
                 }
                 return;
             }
@@ -51,25 +55,36 @@ export const walkDefs = (db, def, f) => {
                 const lang = path[path.length - 1];
                 const langCode = langCodesMap.get(lang);
                 if (!langCode || !db.schema.locales[lang]) {
-                    includeLangDoesNotExist(def, f);
+                    includeLangDoesNotExist(def, include.field);
                     return;
                 }
-                if (!def.include.langTextFields.has(t.prop)) {
-                    def.include.langTextFields.set(t.prop, {
-                        def: t,
-                        codes: new Set(),
-                        fallBacks: [],
-                    });
+                if (!def.include.props.has(t.prop)) {
+                    const opts = include.opts ?? {};
+                    opts.codes = new Set();
+                    opts.fallBacks = [];
+                    if (opts.end && typeof opts.end === 'number') {
+                        opts.end = { [lang]: opts.end };
+                    }
+                    def.include.props.set(t.prop, { def: t, opts });
+                }
+                const opts = def.include.props.get(t.prop).opts;
+                if (include.opts?.end) {
+                    if (typeof include.opts?.end === 'number') {
+                        opts.end[lang] = include.opts?.end;
+                    }
+                    else if (typeof opts.end === 'object') {
+                        opts.end = { ...opts.end, ...include.opts.end };
+                    }
                 }
-                def.include.langTextFields.get(t.prop).codes.add(langCode);
+                opts.codes.add(langCode);
                 return;
             }
             else if (isPropDef(t) &&
                 (t.typeIndex === REFERENCE || t.typeIndex === REFERENCES)) {
                 const refDef = createOrGetRefQueryDef(db, def, t);
                 const f = path.slice(i + 1).join('.');
-                if (!includeProp(refDef, refDef.props[f])) {
-                    includeField(refDef, f);
+                if (!includeProp(refDef, refDef.props[f], include.opts)) {
+                    includeField(refDef, { field: f, opts: include.opts });
                 }
                 return;
             }
@@ -78,17 +93,17 @@ export const walkDefs = (db, def, f) => {
         if (tree) {
             const endFields = getAllFieldFromObject(tree);
             for (const field of endFields) {
-                walkDefs(db, def, field);
+                walkDefs(db, def, { field, opts: include.opts });
             }
         }
     }
     else if (prop.typeIndex === REFERENCE || prop.typeIndex === REFERENCES) {
         const refDef = createOrGetRefQueryDef(db, def, prop);
-        includeAllProps(refDef);
+        includeAllProps(refDef, include.opts);
         return;
     }
     else {
-        includeProp(def, prop);
+        includeProp(def, prop, include.opts);
     }
 };
 //# sourceMappingURL=walk.js.map

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

@@ -1,11 +1,10 @@
 export * from './queryDef.js';
 export * from './types.js';
 export * from './include/props.js';
-export * from './include/toBuffer.js';
-export * from './toByteCode/toBuffer.js';
+export * from './include/toByteCode.js';
+export * from './toByteCode/toByteCode.js';
 export * from './filter/filter.js';
 export * from './filter/toBuffer.js';
 export * from './sort.js';
 export * from './debug.js';
-export * from './read/read.js';
 export * from './aggregates/aggregation.js';

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

@@ -1,12 +1,11 @@
 export * from './queryDef.js';
 export * from './types.js';
 export * from './include/props.js';
-export * from './include/toBuffer.js';
-export * from './toByteCode/toBuffer.js';
+export * from './include/toByteCode.js';
+export * from './toByteCode/toByteCode.js';
 export * from './filter/filter.js';
 export * from './filter/toBuffer.js';
 export * from './sort.js';
 export * from './debug.js';
-export * from './read/read.js';
 export * from './aggregates/aggregation.js';
 //# sourceMappingURL=query.js.map

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

@@ -1,3 +1,5 @@
 import { DbClient } from '../index.js';
-import { QueryDef, QueryDefType, QueryTarget } from './types.js';
-export declare const createQueryDef: (db: DbClient, type: QueryDefType, target: QueryTarget, skipValidation: boolean) => QueryDef;
+import { EdgeTarget, QueryDef, QueryDefEdges, QueryDefRest, QueryDefType, Target } from './types.js';
+type CreateQueryDefReturn<T extends QueryDefType> = T extends QueryDefType.Edge ? QueryDefEdges : T extends QueryDefType.Root | QueryDefType.Reference | QueryDefType.References ? QueryDefRest : QueryDef;
+export declare function createQueryDef<T extends QueryDefType>(db: DbClient, type: T, target: T extends QueryDefType.Edge ? EdgeTarget : Target, skipValidation: boolean): CreateQueryDefReturn<T>;
+export {};

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

@@ -13,10 +13,8 @@ const createEmptySharedDef = (skipValidation) => {
             fallback: [],
         },
         include: {
-            langTextFields: new Map(),
-            stringFields: new Set(),
+            stringFields: new Map(),
             props: new Map(),
-            propsRead: {},
             main: {
                 len: 0,
                 include: {},
@@ -28,7 +26,7 @@ const createEmptySharedDef = (skipValidation) => {
     };
     return q;
 };
-export const createQueryDef = (db, type, target, skipValidation) => {
+export function createQueryDef(db, type, target, skipValidation) {
     const queryDef = createEmptySharedDef(skipValidation);
     if (type === QueryDefType.Edge) {
         const t = target;
@@ -65,5 +63,5 @@ export const createQueryDef = (db, type, target, skipValidation) => {
         }
         return q;
     }
-};
+}
 //# sourceMappingURL=queryDef.js.map

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

@@ -0,0 +1,3 @@
+import { ReaderLocales, ReaderSchema } from '@based/protocol/db-read';
+import { QueryDef } from './types.js';
+export declare const convertToReaderSchema: (q: QueryDef, locales?: ReaderLocales) => ReaderSchema;