nesoi 3.2.8 → 3.3.0

package/lib/elements/entities/bucket/adapters/browserdb.service.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserDBService = void 0;
+const log_1 = require("../../../../engine/util/log");
+const trx_1 = require("../../../../engine/transaction/trx");
+const service_1 = require("../../../../engine/app/service");
+const memory_nql_1 = require("./memory.nql");
+const browserdb_bucket_adapter_1 = require("./browserdb.bucket_adapter");
+const daemon_1 = require("../../../../engine/daemon");
+/* @nesoi:browser ignore-start */
+const window = {};
+/* @nesoi:browser ignore-end */
+class BrowserDBService extends service_1.Service {
+    constructor() {
+        super(...arguments);
+        // This works on all devices/browsers, and uses IndexedDBShim as a final fallback 
+        this.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB || window.shimIndexedDB;
+        this.connected = false;
+    }
+    async up() {
+        this.nql = new memory_nql_1.MemoryNQLRunner();
+    }
+    async down() {
+        await this.db.close();
+    }
+    // Open (or create) the database
+    connect(buckets) {
+        return new Promise((resolve, reject) => {
+            const request = this.indexedDB.open(this.config.dbName, this.config.dbVersion);
+            request.onupgradeneeded = e => {
+                this.db = e.currentTarget?.result;
+                for (const bucket of buckets) {
+                    const refName = `${bucket.module}::${bucket.name}`;
+                    if (!this.db.objectStoreNames.contains(refName)) {
+                        const autoIncrement = bucket.model.fields.id.type === 'int';
+                        this.db.createObjectStore(refName, {
+                            keyPath: 'id',
+                            autoIncrement
+                        });
+                        log_1.Log.info('bucket', 'BrowserDB', `Store ${refName} created on database ${this.config.dbName}@${this.config.dbVersion}`);
+                    }
+                }
+            };
+            request.onsuccess = e => {
+                const db = e.target?.result;
+                resolve(db);
+            };
+            request.onerror = e => {
+                log_1.Log.error('bucket', 'browserDB', e.toString());
+                reject(e);
+            };
+        });
+    }
+    static async db(service, module) {
+        if (!service.db) {
+            log_1.Log.info('service', 'BrowserDB', 'Connecting to BrowserDB database');
+            const modules = daemon_1.Daemon.getModules(module.daemon);
+            const buckets = Object.values(modules)
+                .map(module => Object.values(module.buckets))
+                .flat(1)
+                .filter(b => b.adapter instanceof browserdb_bucket_adapter_1.BrowserDBBucketAdapter)
+                .map(b => b.schema);
+            service.db = await service.connect(buckets);
+        }
+        return service.db;
+    }
+    static wrap(service) {
+        return async (trx, fn, services) => {
+            const module = trx.engine.getModule();
+            const db = await BrowserDBService.db(services[service], module);
+            const refNames = Object.keys(module.buckets)
+                .map(key => key.includes('::')
+                ? key
+                : `${module.name}::${key}`);
+            const trxData = {};
+            trx_1.Trx.set(trx.root, service + '.trxData', trxData);
+            const output = await fn(trx.root);
+            const dbTrx = db.transaction(refNames, 'readwrite');
+            for (const tag in trxData) {
+                const store = dbTrx.objectStore(tag);
+                for (const id in trxData[tag]) {
+                    const obj = trxData[tag][id];
+                    if ('__delete' in obj) {
+                        store.delete(id);
+                    }
+                    else {
+                        store.put(obj);
+                    }
+                }
+            }
+            dbTrx.commit();
+            return output;
+        };
+    }
+}
+exports.BrowserDBService = BrowserDBService;
+BrowserDBService.defaultName = 'idb';

package/lib/elements/entities/bucket/adapters/bucket_adapter.d.ts

@@ -4,6 +4,7 @@ import { BucketCacheSync } from '../cache/bucket_cache';
 import { NQL_AnyQuery, NQL_Pagination } from '../query/nql.schema';
 import { NQLRunner, NQL_Result } from '../query/nql_engine';
 import { $Bucket } from "../../..";
+import { BucketMetadata } from "../../../../engine/transaction/trx_engine";
 export type BucketAdapterConfig = {
     meta: {
         created_at: string;
@@ -139,7 +140,11 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
     query<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], config?: {
         view?: string;
         metadataOnly?: MetadataOnly;
-    }, runner?: NQLRunner): Promise<NQL_Result<MetadataOnly extends true ? {
+    }, custom?: {
+        module?: string;
+        runners?: Record<string, NQLRunner>;
+        metadata?: BucketMetadata;
+    }): Promise<NQL_Result<MetadataOnly extends true ? {
         id: Obj['id'];
         [x: string]: any;
     } : Obj>>;

package/lib/elements/entities/bucket/adapters/bucket_adapter.js

@@ -25,14 +25,15 @@ class BucketAdapter {
     /**
      * Return the results of a query
      */
-    async query(trx, query, pagination, params, config, runner) {
+    async query(trx, query, pagination, params, config, 
+    // When running a temporary local memory adapter,
+    // these are required
+    custom) {
         const module = trx_node_1.TrxNode.getModule(trx);
-        const refName = (module.name === this.schema.module
-            ? '' : `${this.schema.module}::`)
-            + this.schema.name;
-        const compiled = await nql_compiler_1.NQL_Compiler.build(module, refName, query);
+        const moduleName = custom?.module || module.name;
+        const compiled = await nql_compiler_1.NQL_Compiler.build(module.daemon, moduleName, this.schema.name, query, custom?.metadata);
         const view = config?.view ? this.schema.views[config.view] : undefined;
-        const result = await module.nql.run(trx, compiled, pagination, params, view, runner);
+        const result = await module.nql.run(trx, compiled, pagination, params, view, custom?.runners);
         if (config?.metadataOnly) {
             result.data = result.data.map(obj => ({
                 id: obj.id,

package/lib/elements/entities/bucket/adapters/json.bucket_adapter.d.ts

@@ -41,4 +41,4 @@ export declare class JSONBucketAdapter<B extends $Bucket, Obj extends B['#data']
         reset: boolean;
     }>;
 }
-export type AnyMemoryBucketAdapter = JSONBucketAdapter<any, any>;
+export type AnyJSONBucketAdapter = JSONBucketAdapter<any, any>;

package/lib/elements/entities/bucket/adapters/json.bucket_adapter.js

@@ -1,4 +1,5 @@
 "use strict";
+/* @nesoi:browser ignore-file */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/lib/elements/entities/bucket/adapters/memory.bucket_adapter.d.ts

@@ -17,6 +17,7 @@ import { BucketCacheSync } from '../cache/bucket_cache';
 export declare class MemoryBucketAdapter<B extends $Bucket, Obj extends B['#data']> extends BucketAdapter<Obj> {
     schema: B;
     data: NoInfer<Record<Obj['id'], Obj>>;
+    private model;
     constructor(schema: B, data?: NoInfer<Record<Obj['id'], Obj>>, config?: BucketAdapterConfig);
     getQueryMeta(): {
         scope: string;

package/lib/elements/entities/bucket/adapters/memory.bucket_adapter.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryBucketAdapter = void 0;
 const bucket_adapter_1 = require("./bucket_adapter");
-const crypto_1 = require("crypto");
 const memory_nql_1 = require("./memory.nql");
-const bucket_model_schema_1 = require("../model/bucket_model.schema");
+const hash_1 = require("../../../../engine/util/hash");
+const bucket_model_1 = require("../model/bucket_model");
 /**
  * @category Adapters
  * @subcategory Entity
@@ -23,6 +23,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         this.schema = schema;
         this.data = data;
         nql.bind(this);
+        this.model = new bucket_model_1.BucketModel(schema, config);
     }
     getQueryMeta() {
         return {
@@ -45,7 +46,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
     }
     /* Write Operations */
     async create(trx, obj) {
-        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        const input = this.model.copy(obj);
         if (!input.id) {
             const lastId = (await this.index(trx))
                 .map((_obj) => parseInt(_obj.id))
@@ -53,7 +54,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
             input.id = lastId + 1;
         }
         this.data[input.id] = input;
-        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        const output = this.model.copy(input);
         return Promise.resolve(output);
     }
     async createMany(trx, objs) {
@@ -67,9 +68,9 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         if (!obj.id || !this.data[obj.id]) {
             throw new Error(`Object with id ${obj.id} not found for replace`);
         }
-        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        const input = this.model.copy(obj);
         this.data[input.id] = input;
-        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        const output = this.model.copy(input);
         return Promise.resolve(output);
     }
     async replaceMany(trx, objs) {
@@ -85,7 +86,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
             throw new Error(`Object with id ${obj.id} not found for patch`);
         }
         const data = this.data[obj.id];
-        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        const input = this.model.copy(obj);
         for (const key in input) {
             if (input[key] === null) {
                 delete data[key];
@@ -94,7 +95,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
                 data[key] = input[key];
             }
         }
-        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, data, this.config.meta);
+        const output = this.model.copy(data);
         return Promise.resolve(output);
     }
     async patchMany(trx, objs) {
@@ -106,7 +107,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         return Promise.resolve(out);
     }
     async put(trx, obj) {
-        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        const input = this.model.copy(obj);
         if (!input.id) {
             const lastId = (await this.index(trx))
                 .map((_obj) => parseInt(_obj.id))
@@ -114,7 +115,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
             input.id = lastId + 1;
         }
         this.data[input.id] = input;
-        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        const output = this.model.copy(input);
         return Promise.resolve(output);
     }
     async putMany(trx, objs) {
@@ -124,12 +125,12 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         let id = lastId + 1;
         const out = [];
         for (const obj of objs) {
-            const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+            const input = this.model.copy(obj);
             if (!input.id) {
                 input.id = id;
             }
             this.data[input.id] = input;
-            const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+            const output = this.model.copy(input);
             out.push(output);
             id++;
         }
@@ -195,7 +196,7 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
     async syncAll(trx, lastHash, lastUpdateEpoch = 0) {
         // 1. Hash the current ids
         const idStr = Object.keys(this.data).sort().join('');
-        const hash = (0, crypto_1.createHash)('md5').update(idStr).digest('hex');
+        const hash = hash_1.Hash.string(idStr);
         // 2. If hash changed, return a reset sync with all objects
         if (hash !== lastHash) {
             let updateEpoch = 0;

package/lib/elements/entities/bucket/adapters/memory.nql.js

@@ -85,52 +85,49 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
      * @returns A dict of results by id
      */
     filter(part, objs, params) {
+        // Accumulate results from n intersections,
+        // avoiding a re-check of already matched objects.
         const _union = (union, objs, params) => {
-            // console.log(`::UNION (objs: ${Object.keys(objs)})\n`)
             const out = {};
+            const remaining = { ...objs };
             for (const inter of union.inters) {
-                // Pass `out` as blacklist: if already found, can be skipped
-                const black = out;
-                const interOut = _inter(inter, objs, params, black);
+                if (Object.keys(remaining).length === 0)
+                    break;
+                const interOut = _inter(inter, remaining, params);
                 Object.assign(out, interOut);
+                for (const k in interOut) {
+                    delete remaining[k];
+                }
             }
-            // console.log('    -> union out\n', out);
             return out;
         };
-        const _inter = (inter, objs, params, black = {}) => {
-            // console.log(`::INTER (objs: ${Object.keys(objs)}, black: ${Object.keys(black)})\n`)
-            // Create white set, which will be modified by rules running on this union
-            const white = new Set(Object.keys(objs));
+        // Sieves results from n unions or rules,
+        // avoiding a re-check of already filtered-out objects.
+        const _inter = (inter, objs, params) => {
             let out = {};
+            const remaining = { ...objs };
             for (const rule of inter.rules) {
+                if (Object.keys(remaining).length === 0)
+                    break;
                 // <Union>
                 if ('inters' in rule) {
-                    if (!_union(rule, objs, params))
-                        return false;
+                    out = _union(rule, remaining, params);
                 }
                 // <Rule>
                 else {
-                    const ruleOut = _rule(rule, objs, params, black, white);
-                    out = ruleOut;
+                    out = _rule(rule, remaining, params);
+                }
+                for (const k in remaining) {
+                    if (!(k in out)) {
+                        delete remaining[k];
+                    }
                 }
-                if (white.size == 0)
-                    break;
-                // console.log(`    -> white: ${Array.from(white.values())}\n`)
             }
-            // console.log(`    -> inter out: ${Object.keys(out)}\n`)
             return out;
         };
-        const _rule = (rule, objs, params, black, white) => {
-            // console.log(`::RULE (objs: ${Object.keys(objs)}, black: ${Object.keys(black)}, white: ${Array.from(white.values())})\n`)
+        const _rule = (rule, objs, params) => {
             const out = {};
             for (const id in objs) {
-                if (!white.has(id)) {
-                    continue;
-                }
-                if (id in black) {
-                    white.delete(id);
-                    continue;
-                }
                 const obj = objs[id];
                 let match = false;
                 for (const paramGroup of params) {
@@ -141,11 +138,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                 if (rule.not) {
                     match = !match;
                 }
-                if (!match) {
-                    white.delete(id);
-                    continue;
-                }
-                if (obj !== undefined) {
+                if (match) {
                     if (rule.select) {
                         out[obj.id] = obj[rule.select];
                     }
@@ -154,11 +147,9 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                     }
                 }
             }
-            // console.log(`    -> rule out: ${Object.keys(out)}\n`)
             return out;
         };
         const _obj = (rule, obj, params) => {
-            // console.log(`::OBJ (obj: ${obj.id})\n`)
             const fieldValue = tree_1.Tree.get(obj, rule.fieldpath);
             // Value is undefined, only 'present' rule applies
             if (fieldValue === undefined) {
@@ -200,7 +191,6 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             else if ('static' in rule.value) {
                 queryValue = rule.value.static;
             }
-            // console.log({fieldpath: rule.fieldpath, op: rule.op, fieldValue, queryValue});
             // Check each operation
             // (Compatible operations and types have already been validated)
             if (rule.op === '<') {
@@ -240,6 +230,14 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                         return fieldValue.includes(queryValue);
                     }
                 }
+                else if (Array.isArray(fieldValue)) {
+                    if (rule.case_i) {
+                        return fieldValue.some(f => f.toLowerCase().includes(queryValue.toLowerCase()));
+                    }
+                    else {
+                        return fieldValue.includes(queryValue);
+                    }
+                }
                 else {
                     if (rule.case_i) {
                         return Object.keys(fieldValue).some(f => f.toLowerCase().includes(queryValue.toLowerCase()));
@@ -258,9 +256,17 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                         return queryValue.some(q => fieldValue.includes(q));
                     }
                 }
+                else if (Array.isArray(fieldValue)) {
+                    if (rule.case_i) {
+                        return queryValue.some(q => fieldValue.some(f => f.toLowerCase().includes(q.toLowerCase())));
+                    }
+                    else {
+                        return queryValue.some(q => fieldValue.includes(q));
+                    }
+                }
                 else {
                     if (rule.case_i) {
-                        return queryValue.some(q => Object.keys(q).some(k => fieldValue.toLowerCase().includes(q.toLowerCase())));
+                        return queryValue.some(q => Object.keys(fieldValue).some(k => k.toLowerCase().includes(q.toLowerCase())));
                     }
                     else {
                         return queryValue.some(q => q in fieldValue);

package/lib/elements/entities/bucket/bucket.builder.d.ts

@@ -4,15 +4,14 @@ import { $BucketView, $BucketViews } from './view/bucket_view.schema';
 import { BucketViewDef } from './view/bucket_view.builder';
 import { $Bucket, $BucketTenancy } from './bucket.schema';
 import { BucketModelDef } from './model/bucket_model.builder';
-import { $BucketModelFields } from './model/bucket_model.schema';
+import { $BucketModel } from './model/bucket_model.schema';
 import { $BucketViewDataInfer, $BucketViewFieldsInfer } from './bucket.infer';
 import { $BucketGraphLinksInfer } from './graph/bucket_graph.infer';
 import { $BucketGraph } from './graph/bucket_graph.schema';
-import { $Dependency, ResolvedBuilderNode } from "../../../engine/dependency";
+import { Dependency, ResolvedBuilderNode } from "../../../engine/dependency";
 import { ModuleTree } from "../../../engine/tree";
 import { BucketModelpathInfer, BucketModelInfer, BucketQuerypathInfer } from './model/bucket_model.infer';
 import { Overlay } from "../../../engine/util/type";
-import { $Constants } from '../constants/constants.schema';
 import { NesoiObj } from "../../../engine/data/obj";
 /**
  * @category Builders
@@ -32,7 +31,7 @@ export declare class BucketBuilder<Space extends $Space, Module extends $Module,
     private _tenancy?;
     constructor(module: string, name: string);
     as(alias: string): this;
-    extend<N extends Exclude<BucketName<Module>, Bucket['name']>>(name: N): BucketBuilder<Space, Module, Module["buckets"][N]>;
+    extend<N extends Exclude<BucketName<Module>, Bucket['name']>>(nameOrShort: N): BucketBuilder<Space, Module, Module["buckets"][N]>;
     model<Def extends BucketModelDef<Space, Module>, Obj = BucketModelInfer<Def>, Modelpath extends {} = BucketModelpathInfer<Def>, Querypath extends {} = BucketQuerypathInfer<Def>>($: Def): BucketBuilder<Space, Overlay<Module, {
         buckets: Overlay<Module["buckets"], { [K in Bucket["name"]]: Overlay<Bucket, {
             '#data': Obj & NesoiObj;
@@ -48,7 +47,7 @@ export declare class BucketBuilder<Space extends $Space, Module extends $Module,
      * Optional query to be appended to every read of this bucket, based on the user
      * This allows implementing complex multi-tenancy rules through NQL
      */
-    tenancy<T extends $BucketTenancy<Module, Bucket>>($: T): void;
+    tenancy<T extends $BucketTenancy<Module, Bucket>>($: T): this;
     graph<Def extends BucketGraphDef<Module, Bucket>>($: Def): BucketBuilder<Space, Module, Overlay<Bucket, {
         graph: Overlay<Bucket["graph"], {
             links: $BucketGraphLinksInfer<ReturnType<Def>>;
@@ -61,9 +60,8 @@ export declare class BucketBuilder<Space extends $Space, Module extends $Module,
         }; };
     }>;
     static build(node: BucketBuilderNode, tree: ModuleTree): $Bucket;
-    static mergeModelEnums(fields: $BucketModelFields, constants: $Constants): void;
-    static buildGraph(node: BucketBuilderNode, tree: ModuleTree, extend?: $Dependency): $BucketGraph;
-    static buildViews(builder: AnyBucketBuilder, graph: $BucketGraph, tree: ModuleTree, extend?: $Dependency): $BucketViews;
+    static buildGraph(node: BucketBuilderNode, tree: ModuleTree, extend?: Dependency): $BucketGraph;
+    static buildViews(builder: AnyBucketBuilder, graph: $BucketGraph, tree: ModuleTree, model: $BucketModel, extend?: Dependency): $BucketViews;
     static checkComposition(node: BucketBuilderNode, graph: $BucketGraph): void;
 }
 export type AnyBucketBuilder = BucketBuilder<any, any>;

package/lib/elements/entities/bucket/bucket.builder.js

@@ -5,11 +5,11 @@ const bucket_graph_builder_1 = require("./graph/bucket_graph.builder");
 const bucket_view_builder_1 = require("./view/bucket_view.builder");
 const bucket_schema_1 = require("./bucket.schema");
 const bucket_model_builder_1 = require("./model/bucket_model.builder");
+const bucket_model_schema_1 = require("./model/bucket_model.schema");
 const bucket_model_convert_1 = require("./model/bucket_model.convert");
 const bucket_model_field_builder_1 = require("./model/bucket_model_field.builder");
 const bucket_graph_link_builder_1 = require("./graph/bucket_graph_link.builder");
 const dependency_1 = require("../../../engine/dependency");
-const constants_schema_1 = require("../constants/constants.schema");
 const error_1 = require("../../../engine/data/error");
 /**
  * @category Builders
@@ -27,15 +27,15 @@ class BucketBuilder {
         this._alias = alias;
         return this;
     }
-    extend(name) {
-        this._extend = new dependency_1.$Dependency(this.module, 'bucket', name);
+    extend(nameOrShort) {
+        const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', nameOrShort);
+        this._extend = new dependency_1.Dependency(this.module, tag, { build: true });
         return this;
     }
     model($) {
         const fieldBuilder = new bucket_model_field_builder_1.BucketModelFieldFactory(this.module);
         const fields = $(fieldBuilder);
-        const builder = new bucket_model_builder_1.BucketModelBuilder(this.module).fields(fields);
-        this._model = bucket_model_builder_1.BucketModelBuilder.build(builder);
+        this._model = new bucket_model_builder_1.BucketModelBuilder(this.module).fields(fields);
         return this;
     }
     /**
@@ -44,6 +44,7 @@ class BucketBuilder {
      */
     tenancy($) {
         this._tenancy = $;
+        return this;
     }
     graph($) {
         const linkFactory = new bucket_graph_link_builder_1.BucketGraphLinkFactory(this.module);
@@ -59,44 +60,28 @@ class BucketBuilder {
     }
     // Build
     static build(node, tree) {
+        const model = node.builder._extend
+            ? new bucket_model_schema_1.$BucketModel({}, {})
+            : bucket_model_builder_1.BucketModelBuilder.build(node.builder._model, tree);
         // If there's an external bucket linked, merge some of
         // the information before starting.
         let $ext;
         const extend = node.builder._extend;
         if (extend) {
-            $ext = tree.getSchema(extend);
+            $ext = dependency_1.Tag.resolve(extend.tag, tree);
             // Model
-            node.builder._model = Object.assign({}, $ext?.model || {}, node.builder._model);
-            // Enums
-            // (In order to avoid having to import constants definitions for extended buckets)
-            const constants = tree.getSchema({
-                module: extend.module,
-                type: 'constants',
-                name: '*'
-            });
-            this.mergeModelEnums(node.builder._model.fields, constants);
+            model.fields = Object.assign({}, $ext.model.fields, model.fields);
+            model.defaults = Object.assign({}, $ext.model.defaults, model.defaults);
         }
         const graph = BucketBuilder.buildGraph(node, tree, extend);
-        const views = BucketBuilder.buildViews(node.builder, graph, tree, extend);
-        node.schema = new bucket_schema_1.$Bucket(node.builder.module, node.builder.name, node.builder._alias || $ext?.alias || node.builder.name, node.builder._model, graph, views, node.builder._tenancy, extend);
+        const views = BucketBuilder.buildViews(node.builder, graph, tree, model, extend);
+        node.schema = new bucket_schema_1.$Bucket(node.builder.module, node.builder.name, node.builder._alias || $ext?.alias || node.builder.name, model, graph, views, node.builder._tenancy, extend?.tag);
         return node.schema;
     }
-    static mergeModelEnums(fields, constants) {
-        Object.values(fields).forEach(field => {
-            if (field.type === 'enum' && typeof field.meta?.enum?.options === 'string') {
-                field.meta.enum = {
-                    options: constants_schema_1.$ConstantEnum.keys(constants.enums[field.meta.enum.options])
-                };
-            }
-            if (field.children) {
-                this.mergeModelEnums(field.children, constants);
-            }
-        });
-    }
     static buildGraph(node, tree, extend) {
         const links = {};
         if (extend) {
-            const ext = tree.getSchema(extend);
+            const ext = dependency_1.Tag.resolve(extend.tag, tree);
             Object.assign(links, ext.graph.links);
         }
         const graphBuilder = new bucket_graph_builder_1.BucketGraphBuilder().links(node.builder._graph);
@@ -104,16 +89,16 @@ class BucketBuilder {
         graph.links = Object.assign(graph.links, links);
         return graph;
     }
-    static buildViews(builder, graph, tree, extend) {
+    static buildViews(builder, graph, tree, model, extend) {
         const views = {
-            default: (0, bucket_model_convert_1.convertToView)(builder._model, 'default')
+            default: (0, bucket_model_convert_1.convertToView)(model, 'default')
         };
         if (extend) {
-            const ext = tree.getSchema(extend);
+            const ext = dependency_1.Tag.resolve(extend.tag, tree);
             Object.assign(views, ext.views);
         }
         for (const v in builder._views) {
-            views[v] = bucket_view_builder_1.BucketViewBuilder.build(builder._views[v], builder._model, graph, views);
+            views[v] = bucket_view_builder_1.BucketViewBuilder.build(builder._views[v], model, graph, views);
         }
         return views;
     }

package/lib/elements/entities/bucket/bucket.d.ts

@@ -11,7 +11,7 @@ import { CreateObj, PatchObj, PutObj } from './bucket.types';
 import { NQL_Result } from './query/nql_engine';
 import { $BucketModelFields } from './model/bucket_model.schema';
 import { DriveAdapter } from '../drive/drive_adapter';
-import { IService } from "../../../engine/apps/service";
+import { IService } from "../../../engine/app/service";
 import { AnyModule } from "../../../engine/module";
 /**
  * **This should only be used inside a `#composition` of a bucket `create`** to refer to the parent id, which doesn't exist yet.
@@ -39,7 +39,7 @@ export declare class Bucket<M extends $Module, $ extends $Bucket> {
     drive?: DriveAdapter;
     constructor(module: AnyModule, schema: $, config?: BucketConfig<any, any, any> | undefined, services?: Record<string, IService>);
     getQueryMeta(): {
-        bucket: $;
+        schema: $;
         scope: string;
         avgTime: number;
     };

package/lib/elements/entities/bucket/bucket.infer.d.ts

@@ -1,14 +1,14 @@
 import { $BucketViewField, $BucketViewFields } from './view/bucket_view.schema';
-import { BucketViewFieldBuilder, BucketViewFieldBuilderTree } from './view/bucket_view_field.builder';
-export type $BucketViewFieldsInfer<Builder extends BucketViewFieldBuilderTree> = Builder extends (...args: any[]) => $BucketViewFields ? ReturnType<Builder> : {
-    [K in keyof Builder]: Builder[K] extends BucketViewFieldBuilderTree ? ($BucketViewField & {
+import { BucketViewFieldBuilder, BucketViewFieldBuilders } from './view/bucket_view_field.builder';
+export type $BucketViewFieldsInfer<Builder extends BucketViewFieldBuilders> = Builder extends (...args: any[]) => $BucketViewFields ? ReturnType<Builder> : {
+    [K in keyof Builder]: Builder[K] extends BucketViewFieldBuilders ? ($BucketViewField & {
         '#data': $BucketViewFieldsInfer<Builder[K]>;
     }) : Builder[K] extends BucketViewFieldBuilder<any, any, any> ? $BucketViewField & {
         '#data': Builder[K] extends BucketViewFieldBuilder<infer X, any> ? X : never;
     } : never;
 };
-export type $BucketViewDataInfer<Builder extends BucketViewFieldBuilderTree> = {
-    [K in keyof Builder]: Builder[K] extends BucketViewFieldBuilderTree ? $BucketViewDataInfer<Builder[K]> : Builder[K] extends BucketViewFieldBuilder<infer X, any> ? X : never;
+export type $BucketViewDataInfer<Builder extends BucketViewFieldBuilders> = {
+    [K in keyof Builder]: Builder[K] extends BucketViewFieldBuilders ? $BucketViewDataInfer<Builder[K]> : Builder[K] extends BucketViewFieldBuilder<infer X, any> ? X : never;
 };
 export type $BucketViewFieldBuilderInfer<Data> = {
     [K in keyof Data]: BucketViewFieldBuilder<Data[K], any>;