nesoi 3.0.0

package/lib/elements/entities/bucket/cache/bucket_cache.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketCache = exports.BucketCacheEntry = void 0;
+const log_1 = require("../../../../engine/util/log");
+const memory_bucket_adapter_1 = require("../adapters/memory.bucket_adapter");
+const datetime_1 = require("../../../../engine/data/datetime");
+class BucketCacheEntry {
+    constructor(id, obj, updateEpoch, syncEpoch) {
+        this.id = id;
+        this.obj = obj;
+        this.updateEpoch = updateEpoch;
+        this.syncEpoch = syncEpoch;
+    }
+}
+exports.BucketCacheEntry = BucketCacheEntry;
+class BucketCache {
+    constructor(bucketName, outerAdapter, config) {
+        this.bucketName = bucketName;
+        this.outerAdapter = outerAdapter;
+        this.config = config;
+        this.innerAdapter = this.config?.adapter || new memory_bucket_adapter_1.MemoryBucketAdapter({}, {});
+    }
+    async get(trx, id) {
+        const mode = this.config?.mode?.get;
+        if (mode === 'one') {
+            const { action, sync } = await this.syncOne(trx, id);
+            log_1.Log.debug('bucket', this.bucketName, `CACHE get.one, ${action}`);
+            return sync?.obj;
+        }
+        if (mode === 'past') {
+            const { action, sync } = await this.syncOneAndPast(trx, id);
+            log_1.Log.debug('bucket', this.bucketName, `CACHE get.past, ${action}`);
+            return sync?.obj;
+        }
+        if (mode === 'all') {
+            const { action, sync } = await this.syncAll(trx);
+            log_1.Log.debug('bucket', this.bucketName, `CACHE get.sync, ${action}`);
+            return sync.find(s => s.obj.id === id)?.obj;
+        }
+        return this.outerAdapter.get(trx, id);
+    }
+    async index(trx) {
+        const mode = this.config?.mode?.index;
+        if (mode === 'all') {
+            const { action, sync } = await this.syncAll(trx);
+            log_1.Log.debug('bucket', this.bucketName, `CACHE index.sync, ${action}`);
+            return sync.map(s => s.obj);
+        }
+        return this.outerAdapter.index(trx);
+    }
+    async query(trx, view, query, pagination) {
+        const mode = this.config?.mode?.query;
+        if (mode === 'incremental') {
+            const { action, sync } = await this.syncQuery(trx, view, query, pagination);
+            log_1.Log.debug('bucket', this.bucketName, `CACHE query.incremental, ${action}`);
+            return sync.map(s => s.obj);
+        }
+        if (mode === 'all') {
+            const { action, sync } = await this.syncAll(trx);
+            log_1.Log.debug('bucket', this.bucketName, `CACHE query.sync, ${action}`);
+            return this.innerAdapter.query(trx, query);
+        }
+        return this.outerAdapter.query(trx, query);
+    }
+    /* Cache modes */
+    async syncOne(trx, id) {
+        const localObj = await this.innerAdapter.get(trx, id);
+        if (!localObj) {
+            const obj = await this.outerAdapter.get(trx, id);
+            if (obj) {
+                const entry = new BucketCacheEntry(obj.id, obj, this.outerAdapter.getUpdateEpoch(obj), this.lastSyncEpoch);
+                await this.innerAdapter.put(trx, entry);
+                return { action: 'update', sync: entry };
+            }
+            return { action: 'keep' };
+        }
+        const sync = await this.outerAdapter.syncOne(trx, id, localObj.updateEpoch);
+        if (sync === null) {
+            return { action: 'keep', sync: localObj };
+        }
+        if (sync === 'deleted') {
+            await this.innerAdapter.delete(trx, id);
+            return { action: 'delete' };
+        }
+        localObj.obj = sync.obj;
+        localObj.updateEpoch = sync.updateEpoch;
+        localObj.syncEpoch = datetime_1.NesoiDatetime.now().epoch;
+        await this.innerAdapter.put(trx, localObj);
+        return { action: 'update', sync };
+    }
+    async syncOneAndPast(trx, id) {
+        const localObj = await this.innerAdapter.get(trx, id);
+        if (!localObj) {
+            const obj = await this.outerAdapter.get(trx, id);
+            if (obj) {
+                await this.innerAdapter.put(trx, obj);
+                return { action: 'update', sync: {
+                        obj,
+                        updateEpoch: this.outerAdapter.getUpdateEpoch(obj)
+                    } };
+            }
+            return { action: 'keep' };
+        }
+        const sync = await this.outerAdapter.syncOneAndPast(trx, id, localObj.updateEpoch);
+        if (sync === null) {
+            return { action: 'keep', sync: localObj };
+        }
+        if (sync === 'deleted') {
+            await this.innerAdapter.delete(trx, id);
+            return { action: 'delete' };
+        }
+        await this.innerAdapter.putMany(trx, sync.map(s => s.obj));
+        return { action: 'update', sync: sync.find(s => s.obj.id === id) };
+    }
+    async syncAll(trx) {
+        const sync = await this.outerAdapter.syncAll(trx, this.lastHash, this.lastUpdateEpoch);
+        if (sync === null) {
+            const all = await this.innerAdapter.index(trx);
+            return { action: 'keep', sync: all };
+        }
+        this.lastUpdateEpoch = sync.updateEpoch;
+        this.lastHash = sync.hash;
+        this.lastSyncEpoch = datetime_1.NesoiDatetime.now().epoch;
+        const entries = sync.sync.map(s => new BucketCacheEntry(s.obj.id, s.obj, s.updateEpoch, this.lastSyncEpoch));
+        if (sync.reset) {
+            await this.innerAdapter.deleteEverything(trx);
+            await this.innerAdapter.putMany(trx, entries);
+            return { action: 'reset', sync: sync.sync };
+        }
+        await this.innerAdapter.putMany(trx, entries);
+        return { action: 'update', sync: sync.sync };
+    }
+    async syncQuery(trx, view, query, pagination) {
+        // 1. Query id and epoch from outer adapter
+        const outerMetadata = await this.outerAdapter.query(trx, query, pagination, {
+            metadataOnly: true
+        });
+        if (!outerMetadata.length) {
+            return { action: 'keep', sync: [] };
+        }
+        // 2. Read ids from the inner adapter
+        const innerData = await this.innerAdapter.query(trx, {
+            'id in': outerMetadata.map(obj => obj.id)
+        });
+        // 3. Filter modified query results
+        const outerEpoch = {};
+        for (const i in outerMetadata) {
+            const obj = outerMetadata[i];
+            outerEpoch[obj.id] = this.outerAdapter.getUpdateEpoch(obj);
+        }
+        const queryResults = {};
+        const modifiedIds = [];
+        for (const i in innerData) {
+            const obj = innerData[i];
+            const epoch = outerEpoch[obj.id];
+            if (!epoch || epoch > obj.updateEpoch) {
+                modifiedIds.push(obj.id);
+            }
+            else {
+                queryResults[obj.id] = obj;
+            }
+        }
+        // 4. Nothing changed, return current data
+        if (!modifiedIds.length) {
+            return { action: 'keep', sync: innerData };
+        }
+        // 5. Query modified objects to outer adapter and merge them on results
+        const outerData = await this.outerAdapter.query(trx, {
+            'id in': modifiedIds
+        });
+        for (const i in outerData) {
+            const obj = outerData[i];
+            const updateEpoch = this.outerAdapter.getUpdateEpoch(obj);
+            queryResults[obj.id] = {
+                obj,
+                updateEpoch
+            };
+        }
+        return { action: 'update', sync: Object.values(queryResults) };
+    }
+}
+exports.BucketCache = BucketCache;

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

@@ -0,0 +1,11 @@
+import { $Module } from "../../../../schema";
+import { $BucketGraph } from './bucket_graph.schema';
+import { BucketGraphLinkBuilders, BucketGraphLinkFactory } from './bucket_graph_link.builder';
+import { BucketBuilderNode } from '../bucket.builder';
+import { $Bucket } from '../bucket.schema';
+export declare class BucketGraphBuilder<Module extends $Module> {
+    private _links;
+    links(builders: BucketGraphLinkBuilders): this;
+    static build(node: BucketBuilderNode, builder: BucketGraphBuilder<any>): $BucketGraph;
+}
+export type BucketGraphDef<Module extends $Module, SelfBucket extends $Bucket> = ($: BucketGraphLinkFactory<Module, SelfBucket>) => BucketGraphLinkBuilders;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketGraphBuilder = void 0;
+const bucket_graph_schema_1 = require("./bucket_graph.schema");
+const bucket_graph_link_builder_1 = require("./bucket_graph_link.builder");
+/*
+    Builder
+*/
+class BucketGraphBuilder {
+    constructor() {
+        this._links = {};
+    }
+    links(builders) {
+        this._links = builders;
+        return this;
+    }
+    // Build
+    static build(node, builder) {
+        const links = {};
+        for (const k in builder._links) {
+            const link = builder._links[k];
+            links[k] = bucket_graph_link_builder_1.BucketGraphLinkBuilder.build(node, link, k);
+        }
+        return new bucket_graph_schema_1.$BucketGraph(links);
+    }
+}
+exports.BucketGraphBuilder = BucketGraphBuilder;

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

@@ -0,0 +1,16 @@
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { $Module, ViewName, ViewObj } from "../../../../schema";
+import { Bucket } from '../bucket';
+import { $Bucket } from '../bucket.schema';
+export declare class BucketGraph<M extends $Module, $ extends $Bucket> {
+    private bucket;
+    private bucketName;
+    private schema;
+    constructor(bucket: Bucket<M, $>);
+    readLinkOrFail<LinkName extends keyof $['graph']['links'], LinkBucketName extends $['graph']['links'][LinkName]['bucket']['refName'], LinkBucket extends M['buckets'][LinkBucketName], V extends ViewName<LinkBucket>, Obj extends ViewObj<LinkBucket, V>>(trx: AnyTrxNode, link: LinkName, obj: $['#data'], view?: V, index?: (string | number)[]): Promise<Obj | Obj[]>;
+    readLink<LinkName extends keyof $['graph']['links'], LinkBucketName extends $['graph']['links'][LinkName]['bucket']['refName'], LinkBucket extends M['buckets'][LinkBucketName], V extends ViewName<LinkBucket>, Obj extends ViewObj<LinkBucket, V>>(trx: AnyTrxNode, link: LinkName, obj: $['#data'], view?: V, index?: (string | number)[]): Promise<Obj | Obj[] | undefined>;
+    private readOneLink;
+    private readManyLink;
+    hasLink<LinkName extends keyof $['graph']['links']>(trx: AnyTrxNode, link: LinkName, obj: $['#data']): Promise<boolean>;
+}
+export type AnyBucket = Bucket<any, any>;

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

@@ -0,0 +1,9 @@
+import { Overlay } from "../../../../engine/util/type";
+import { $BucketGraphLink } from './bucket_graph.schema';
+import { BucketGraphLinkBuilder, BucketGraphLinkBuilders } from './bucket_graph_link.builder';
+export type $BucketGraphLinksInfer<Builders extends BucketGraphLinkBuilders> = {
+    [K in keyof Builders]: Builders[K] extends BucketGraphLinkBuilder<any, any, infer Y> ? Overlay<$BucketGraphLink, {
+        '#bucket': Y;
+        '#data': Y['#data'];
+    }> : never;
+};

package/lib/elements/entities/bucket/graph/bucket_graph.infer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/elements/entities/bucket/graph/bucket_graph.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketGraph = void 0;
+const log_1 = require("../../../../engine/util/log");
+const tree_1 = require("../../../../engine/data/tree");
+const error_1 = require("../../../../engine/data/error");
+class BucketGraph {
+    constructor(bucket) {
+        this.bucket = bucket;
+        this.bucketName = bucket.schema.name;
+        this.schema = bucket.schema.graph;
+    }
+    // Graph
+    async readLinkOrFail(trx, link, obj, view = 'default', index = []) {
+        const res = await this.readLink(trx, link, obj, view, index);
+        if (!res) {
+            const linkSchema = this.schema.links[link];
+            // TODO: get bucket alias instead of name (for error message)
+            throw error_1.NesoiError.Bucket.ObjNotFound({ bucket: linkSchema.bucket.name, id: obj.id });
+        }
+        return res;
+    }
+    async readLink(trx, link, obj, view = 'default', index = []) {
+        const schema = this.schema.links[link];
+        log_1.Log.trace('bucket', this.bucketName, `Read link ${link}`, schema);
+        const selfValue = tree_1.Tree.get(obj, schema.selfKey, index);
+        if (!selfValue) {
+            return undefined;
+        }
+        // Validate value type
+        if (schema.many) {
+            if (schema.keyOwner === 'self') {
+                if (!Array.isArray(selfValue)) {
+                    throw error_1.NesoiError.Bucket.Graph.LinkManyRefOnSelfWithoutArrayValue(schema.name);
+                }
+            }
+            else {
+                if (Array.isArray(selfValue)) {
+                    throw error_1.NesoiError.Bucket.Graph.LinkManyRefOffSelfWithArrayValue(schema.name);
+                }
+            }
+        }
+        else {
+            if (Array.isArray(selfValue)) {
+                throw error_1.NesoiError.Bucket.Graph.LinkOneWithArrayValue(schema.name);
+            }
+        }
+        // 
+        const links = schema.many
+            ? await this.readManyLink(trx, schema, selfValue, view)
+            : await this.readOneLink(trx, schema, selfValue, view);
+        if (!schema.many && !schema.optional && !links) {
+            throw error_1.NesoiError.Bucket.Graph.RequiredLinkNotFound(schema.name, selfValue);
+        }
+        return links;
+    }
+    async readOneLink(trx, link, selfValue, view) {
+        const linkBucket = trx.bucket(link.bucket.refName);
+        if (link.keyOwner === 'self' || link.keyOwner === 'other') {
+            const q = linkBucket.query({
+                [link.otherKey]: selfValue
+            }, view);
+            if (link.query) {
+                q.merge(link.query);
+            }
+            return q.first();
+        }
+        else if (link.keyOwner === 'pivot') {
+            const pivotBucket = trx.bucket(link.pivotBucket);
+            const pivotSelfKey = this.bucket.schema.name + '_id';
+            const pivotOtherKey = link.bucket + '_id';
+            const pivotObj = await linkBucket.query({
+                [pivotSelfKey]: selfValue
+            }, view).first();
+            const pivotValue = pivotObj[pivotOtherKey];
+            if (pivotValue === undefined || pivotValue === null) {
+                throw error_1.NesoiError.Bucket.Graph.PivotValueIsUndefined(link.name);
+            }
+            const q = linkBucket.query({
+                [link.otherKey]: pivotValue
+            }, view);
+            if (link.query) {
+                q.merge(link.query);
+            }
+            return q.first();
+        }
+    }
+    async readManyLink(trx, link, selfValue, view) {
+        const linkBucket = trx.bucket(link.bucket.refName);
+        if (link.keyOwner === 'self') {
+            const q = linkBucket.query({
+                [link.otherKey]: selfValue
+            }, view);
+            if (link.query) {
+                q.merge(link.query);
+            }
+            return q.all();
+        }
+        else if (link.keyOwner === 'other') {
+            const q = linkBucket.query({
+                [link.otherKey]: selfValue
+            }, view);
+            if (link.query) {
+                q.merge(link.query);
+            }
+            return q.all();
+        }
+        else if (link.keyOwner === 'pivot') {
+            const pivotBucket = trx.bucket(link.pivotBucket);
+            const pivotSelfKey = this.bucket.schema.name + '_id';
+            const pivotOtherKey = link.bucket + '_id';
+            const q = pivotBucket.query({
+                [pivotSelfKey]: selfValue
+            }, view);
+            if (link.query) {
+                q.merge(link.query);
+            }
+            const pivotObjs = await q.all();
+            const pivotValues = pivotObjs.map(obj => obj[pivotOtherKey]);
+            if (!pivotValues.length) {
+                return [];
+            }
+            return linkBucket.query({
+                [`${link.otherKey} in`]: pivotValues
+            }, view);
+        }
+    }
+    async hasLink(trx, link, obj) {
+        const links = await this.readLink(trx, link, obj);
+        if (Array.isArray(links)) {
+            return !!links.length;
+        }
+        return !!links;
+    }
+}
+exports.BucketGraph = BucketGraph;

package/lib/elements/entities/bucket/graph/bucket_graph.schema.d.ts

@@ -0,0 +1,28 @@
+import { $Dependency } from "../../../../engine/dependency";
+import { $Bucket } from '../bucket.schema';
+import { AnyQuery } from '../query/nql.schema';
+export declare class $BucketGraphLink {
+    name: string;
+    alias: string;
+    bucket: $Dependency;
+    rel: 'aggregation' | 'composition';
+    many: boolean;
+    optional: boolean;
+    keyOwner: 'self' | 'other' | 'pivot';
+    selfKey: string;
+    otherKey: string;
+    pivotBucket?: string | undefined;
+    query?: AnyQuery<any, any> | undefined;
+    $t: string;
+    '#bucket': $Bucket;
+    '#many': boolean;
+    constructor(name: string, alias: string, bucket: $Dependency, rel: 'aggregation' | 'composition', many: boolean, optional: boolean, keyOwner: 'self' | 'other' | 'pivot', selfKey: string, otherKey: string, pivotBucket?: string | undefined, query?: AnyQuery<any, any> | undefined);
+}
+export type $BucketGraphLinks = {
+    [x: string]: $BucketGraphLink;
+};
+export declare class $BucketGraph {
+    links: $BucketGraphLinks;
+    $t: string;
+    constructor(links?: $BucketGraphLinks);
+}

package/lib/elements/entities/bucket/graph/bucket_graph.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$BucketGraph = exports.$BucketGraphLink = void 0;
+class $BucketGraphLink {
+    constructor(name, alias, bucket, rel, many, optional, keyOwner, selfKey, otherKey, pivotBucket, query) {
+        this.name = name;
+        this.alias = alias;
+        this.bucket = bucket;
+        this.rel = rel;
+        this.many = many;
+        this.optional = optional;
+        this.keyOwner = keyOwner;
+        this.selfKey = selfKey;
+        this.otherKey = otherKey;
+        this.pivotBucket = pivotBucket;
+        this.query = query;
+        this.$t = 'bucket.graph.link';
+    }
+}
+exports.$BucketGraphLink = $BucketGraphLink;
+class $BucketGraph {
+    constructor(links = {}) {
+        this.links = links;
+        this.$t = 'bucket.graph';
+    }
+}
+exports.$BucketGraph = $BucketGraph;

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

@@ -0,0 +1,36 @@
+import { $Module } from "../../../../schema";
+import { $BucketGraphLink } from './bucket_graph.schema';
+import { BucketBuilderNode } from '../bucket.builder';
+import { $Dependency } from "../../../../engine/dependency";
+import { $Bucket } from '../bucket.schema';
+import { NQL_Query } from '../query/nql.schema';
+export declare class BucketGraphLinkFactory<Module extends $Module, SelfBucket extends $Bucket, Fieldpaths = NoInfer<SelfBucket['#fieldpath']>> {
+    private module;
+    private alias?;
+    private type;
+    constructor(module: string);
+    as(alias: string): this;
+    get compose(): typeof this;
+    one<N extends keyof Module['buckets'], Bucket extends $Bucket = Module['buckets'][N]>(bucket: N, query: NQL_Query<Module, Bucket, Fieldpaths>): BucketGraphLinkBuilder<Module, SelfBucket, Module["buckets"][N]>;
+    many<N extends keyof Module['buckets'], Bucket extends $Bucket = Module['buckets'][N]>(bucket: N, query: NQL_Query<Module, Bucket, Fieldpaths>): BucketGraphLinkBuilder<Module, SelfBucket, Module["buckets"][N]>;
+}
+export declare class BucketGraphLinkBuilder<Module extends $Module, SelfBucket extends $Bucket, OtherBucket extends $Bucket> {
+    private bucket;
+    private rel;
+    private query;
+    private many;
+    private alias?;
+    private keyOwner;
+    private pivotBucket?;
+    private selfKey?;
+    private otherKey?;
+    private _query?;
+    private _optional;
+    constructor(bucket: $Dependency, rel: 'aggregation' | 'composition', query: NQL_Query<any, any>, many: boolean, alias?: string | undefined);
+    as(alias: string): this;
+    get optional(): this;
+    static build(node: BucketBuilderNode, builder: BucketGraphLinkBuilder<any, any, any>, name: string): $BucketGraphLink;
+}
+export type BucketGraphLinkBuilders = {
+    [x: string]: BucketGraphLinkBuilder<any, any, any>;
+};

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketGraphLinkBuilder = exports.BucketGraphLinkFactory = void 0;
+const bucket_graph_schema_1 = require("./bucket_graph.schema");
+const dependency_1 = require("../../../../engine/dependency");
+/*
+    Factory
+*/
+class BucketGraphLinkFactory {
+    constructor(module) {
+        this.module = module;
+        this.type = 'aggregation';
+    }
+    as(alias) {
+        this.alias = alias;
+        return this;
+    }
+    get compose() {
+        const self = new BucketGraphLinkFactory(this.module);
+        self.type = 'composition';
+        return self;
+    }
+    one(bucket, query) {
+        return new BucketGraphLinkBuilder(new dependency_1.$Dependency(this.module, 'bucket', bucket, true), this.type, query, false, this.alias);
+    }
+    many(bucket, query) {
+        return new BucketGraphLinkBuilder(new dependency_1.$Dependency(this.module, 'bucket', bucket, true), this.type, query, true, this.alias);
+    }
+}
+exports.BucketGraphLinkFactory = BucketGraphLinkFactory;
+/*
+    Builder
+*/
+class BucketGraphLinkBuilder {
+    constructor(bucket, rel, query, many, alias) {
+        this.bucket = bucket;
+        this.rel = rel;
+        this.query = query;
+        this.many = many;
+        this.alias = alias;
+        this.keyOwner = 'self';
+        this._optional = false;
+    }
+    as(alias) {
+        this.alias = alias;
+        return this;
+    }
+    get optional() {
+        this._optional = true;
+        return this;
+    }
+    static build(node, builder, name) {
+        return new bucket_graph_schema_1.$BucketGraphLink(name, builder.alias || name, builder.bucket, builder.rel, builder.many, builder._optional, builder.keyOwner, builder.selfKey || 'id', builder.otherKey || 'id', builder.pivotBucket, builder._query);
+    }
+}
+exports.BucketGraphLinkBuilder = BucketGraphLinkBuilder;

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

@@ -0,0 +1,13 @@
+import { $Module, $Space } from "../../../../schema";
+import { $BucketModel } from './bucket_model.schema';
+import { BucketModelFieldBuilder, BucketModelFieldBuilders, BucketModelFieldFactory } from './bucket_model_field.builder';
+export declare class BucketModelBuilder<Module extends $Module> {
+    private module;
+    constructor(module: string);
+    private builders;
+    fields(builders: BucketModelFieldBuilders<Module>): this;
+    static build(builder: BucketModelBuilder<any>): $BucketModel;
+}
+export type BucketModelDef<Space extends $Space, Module extends $Module> = ($: BucketModelFieldFactory<Space, Module>) => {
+    id: BucketModelFieldBuilder<Module, any>;
+} & BucketModelFieldBuilders<Module>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketModelBuilder = void 0;
+const bucket_model_schema_1 = require("./bucket_model.schema");
+const bucket_model_field_builder_1 = require("./bucket_model_field.builder");
+/*
+    Builder
+*/
+class BucketModelBuilder {
+    constructor(module) {
+        this.module = module;
+        this.builders = {};
+    }
+    fields(builders) {
+        this.builders = builders;
+        return this;
+    }
+    // Build
+    static build(builder) {
+        const fields = bucket_model_field_builder_1.BucketModelFieldBuilder.buildChildren(builder.module, builder.builders);
+        return new bucket_model_schema_1.$BucketModel(fields.schema, fields.defaults);
+    }
+}
+exports.BucketModelBuilder = BucketModelBuilder;

package/lib/elements/entities/bucket/model/bucket_model.convert.d.ts

@@ -0,0 +1,5 @@
+import { $BucketModel, $BucketModelFields } from "./bucket_model.schema";
+import { $BucketView } from "../view/bucket_view.schema";
+import { $Message } from "../../message/message.schema";
+export declare function convertToView<Model extends $BucketModel>(model: Model, name: string, fields?: $BucketModelFields, path?: string): $BucketView;
+export declare function convertToMessage<Model extends $BucketModel>(module: string, model: Model, name: string, alias: string, include?: string[], exclude?: string[]): $Message;

package/lib/elements/entities/bucket/model/bucket_model.convert.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToView = convertToView;
+exports.convertToMessage = convertToMessage;
+const bucket_view_builder_1 = require("../view/bucket_view.builder");
+const bucket_view_schema_1 = require("../view/bucket_view.schema");
+const message_template_schema_1 = require("../../message/template/message_template.schema");
+const bucket_graph_schema_1 = require("../graph/bucket_graph.schema");
+const bucket_view_field_builder_1 = require("../view/bucket_view_field.builder");
+const message_schema_1 = require("../../message/message.schema");
+const dependency_1 = require("../../../../engine/dependency");
+function convertToView(model, name, fields = model.fields, path) {
+    const view = new bucket_view_builder_1.BucketViewBuilder(name);
+    const convertFields = (fields) => {
+        const viewFields = {};
+        for (const f in fields) {
+            const field = fields[f];
+            const $ = new bucket_view_field_builder_1.BucketViewFieldFactory(view);
+            const key = (path ? path + '.' : '')
+                + field.name;
+            const builder = $.model(key);
+            const graph = new bucket_graph_schema_1.$BucketGraph();
+            viewFields[f] = bucket_view_field_builder_1.BucketViewFieldBuilder.build(builder, model, graph, {}, field.name);
+        }
+        return viewFields;
+    };
+    return new bucket_view_schema_1.$BucketView(name, convertFields(fields));
+}
+function convertToMessage(module, model, name, alias, include = [], exclude = []) {
+    const convertFields = (fields, include = [], exclude = [], root = '') => {
+        const msgFields = {};
+        for (const f in fields) {
+            const field = fields[f];
+            const path = root.length ? `${root}.${f}` : f;
+            if ((include.length && !include.includes(path))
+                || exclude.includes(path)) {
+                continue;
+            }
+            msgFields[f] = new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, path, field.array, field.required, undefined, false, [], {
+                enum: field._enum ? {
+                    options: field._enum.options,
+                    dep: field._enum.dep ? new dependency_1.$Dependency(module, 'constants', `${field._enum.dep.module}::${field._enum.dep.name}`) : undefined
+                } : undefined
+            }, field.children ? convertFields(field.children, include, exclude) : undefined);
+        }
+        return msgFields;
+    };
+    const msgFields = convertFields(model.fields, include, exclude);
+    const template = new message_template_schema_1.$MessageTemplate(msgFields);
+    return new message_schema_1.$Message(module, name, alias, template);
+}

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

@@ -0,0 +1,13 @@
+import { MergeUnion } from "../../../../engine/util/type";
+import { BucketModelDef } from './bucket_model.builder';
+import { BucketModelFieldBuilder, BucketModelFieldBuilders } from './bucket_model_field.builder';
+export type BucketModelObjInfer<Builders extends BucketModelFieldBuilders<any>> = {
+    [K in keyof Builders]: Builders[K] extends BucketModelFieldBuilder<any, any, any, infer X> ? X : BucketModelObjInfer<Builders[K] & BucketModelFieldBuilders<any>>;
+};
+export type BucketModelInfer<Def extends BucketModelDef<any, any>> = BucketModelObjInfer<ReturnType<Def>>;
+export type BucketFieldpathObjInfer<Builders extends BucketModelFieldBuilders<any>, Prefix extends string> = MergeUnion<{
+    [K in keyof Builders]: Builders[K] extends BucketModelFieldBuilder<any, any, any, any, infer X> ? {
+        [J in keyof X as `${Prefix}${K & string}${J & string}`]: X[J];
+    } : never;
+}[keyof Builders]>;
+export type BucketFieldpathInfer<Def extends BucketModelDef<any, any>, Prefix extends string = ''> = BucketFieldpathObjInfer<ReturnType<Def>, Prefix>;

package/lib/elements/entities/bucket/model/bucket_model.infer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });