nesoi 3.0.8 → 3.0.10

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

@@ -4,6 +4,10 @@ import { BucketBuilderNode } from '../bucket.builder';
 import { $Dependency } from "../../../../engine/dependency";
 import { $Bucket } from '../bucket.schema';
 import { NQL_AnyQuery, NQL_Query } from '../query/nql.schema';
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class BucketGraphLinkFactory<Module extends $Module, SelfBucket extends $Bucket, Fieldpaths = NoInfer<SelfBucket['#fieldpath']>> {
     private module;
     private alias?;
@@ -14,6 +18,10 @@ export declare class BucketGraphLinkFactory<Module extends $Module, SelfBucket e
     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]>;
 }
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class BucketGraphLinkBuilder<Module extends $Module, SelfBucket extends $Bucket, OtherBucket extends $Bucket> {
     private bucket;
     private rel;

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

@@ -6,6 +6,10 @@ const dependency_1 = require("../../../../engine/dependency");
 /*
     Factory
 */
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class BucketGraphLinkFactory {
     constructor(module) {
         this.module = module;
@@ -31,6 +35,10 @@ exports.BucketGraphLinkFactory = BucketGraphLinkFactory;
 /*
     Builder
 */
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class BucketGraphLinkBuilder {
     constructor(bucket, rel, query, many, alias) {
         this.bucket = bucket;

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

@@ -1,6 +1,10 @@
 import { $Module, $Space } from "../../../../schema";
 import { $BucketModel } from './bucket_model.schema';
 import { BucketModelFieldBuilder, BucketModelFieldBuilders, BucketModelFieldFactory } from './bucket_model_field.builder';
+/**
+ * @category Builders
+ * @subcategory Entity
+ */
 export declare class BucketModelBuilder<Module extends $Module> {
     private module;
     constructor(module: string);

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

@@ -6,6 +6,10 @@ const bucket_model_field_builder_1 = require("./bucket_model_field.builder");
 /*
     Builder
 */
+/**
+ * @category Builders
+ * @subcategory Entity
+ */
 class BucketModelBuilder {
     constructor(module) {
         this.module = module;

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

@@ -1,5 +1,13 @@
 import { $BucketModel, $BucketModelFields } from "./bucket_model.schema";
 import { $BucketView } from "../view/bucket_view.schema";
 import { $Message } from "../../message/message.schema";
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 export declare function convertToView<Model extends $BucketModel>(model: Model, name: string, fields?: $BucketModelFields, path?: string): $BucketView;
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 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

@@ -9,6 +9,10 @@ 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");
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 function convertToView(model, name, fields = model.fields, path) {
     const view = new bucket_view_builder_1.BucketViewBuilder(name);
     const convertFields = (fields) => {
@@ -26,6 +30,10 @@ function convertToView(model, name, fields = model.fields, path) {
     };
     return new bucket_view_schema_1.$BucketView(name, convertFields(fields));
 }
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 function convertToMessage(module, model, name, alias, include = [], exclude = []) {
     const convertFields = (fields, include = [], exclude = [], root = '') => {
         const msgFields = {};

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

@@ -4,6 +4,10 @@ export type $BucketModelFieldCrypto = {
     algorithm: string;
     key: string;
 };
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $BucketModelField {
     name: string;
     path: string;
@@ -48,6 +52,10 @@ export declare class $BucketModelField {
 export type $BucketModelFields = {
     [x: string]: $BucketModelField;
 };
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $BucketModel {
     fields: $BucketModelFields & {
         id: $BucketModelField;

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

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$BucketModel = exports.$BucketModelField = void 0;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $BucketModelField {
     constructor(name, path, type, alias, array, required, meta, defaultValue, children, or, crypto) {
         this.name = name;
@@ -18,6 +22,10 @@ class $BucketModelField {
     }
 }
 exports.$BucketModelField = $BucketModelField;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $BucketModel {
     constructor(fields, defaults = {}, hasFileField = false, hasEncryptedField = false) {
         this.fields = fields;

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

@@ -6,6 +6,10 @@ import { EnumFromName, EnumName } from '../../constants/constants.schema';
 import { NesoiDecimal } from "../../../../engine/data/decimal";
 import { NesoiDatetime } from "../../../../engine/data/datetime";
 import { NesoiFile } from "../../../../engine/data/file";
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class BucketModelFieldFactory<Space extends $Space, Module extends $Module> {
     private module;
     constructor(module: string);
@@ -70,6 +74,10 @@ export declare class BucketModelFieldFactory<Space extends $Space, Module extend
         '': NesoiFile;
     }>;
 }
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData, TypeAppend = never, Data = DefinedData | TypeAppend, Fieldpath = {
     '': Data;
 }> {

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

@@ -6,6 +6,10 @@ const dependency_1 = require("../../../../engine/dependency");
 /*
     Factory
 */
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class BucketModelFieldFactory {
     constructor(module) {
         this.module = module;
@@ -83,6 +87,10 @@ exports.BucketModelFieldFactory = BucketModelFieldFactory;
 /*
     Builder
 */
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class BucketModelFieldBuilder {
     constructor(module, type, alias, meta, children) {
         this.module = module;

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

@@ -1,5 +1,8 @@
 import { NQL_AnyQuery, NQL_Union, NQL_Part, NQL_Node } from './nql.schema';
 import { AnyModule } from "../../../../engine/module";
+/**
+ * @category NQL
+ * */
 export declare class NQL_RuleTree {
     private module;
     private bucketName;
@@ -28,6 +31,9 @@ export declare class NQL_RuleTree {
 /**
  * Builds a NQL_CompiledQuery by splitting it into multiple parts
  */
+/**
+ * @category NQL
+ * */
 export declare class NQL_Compiler {
     static build(module: AnyModule, bucketName: string, query: NQL_AnyQuery): NQL_CompiledQuery;
     static buildUnion(union: NQL_Union): NQL_CompiledQuery;
@@ -36,6 +42,9 @@ export declare class NQL_Compiler {
  * A query ready to be run by the NQL engine, which will call
  * each NQLRunner with a different adapter
  */
+/**
+ * @category NQL
+ * */
 export declare class NQL_CompiledQuery {
     parts: Record<number, NQL_Part>;
     execOrder: number[];

package/lib/elements/entities/bucket/query/nql_compiler.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NQL_CompiledQuery = exports.NQL_Compiler = exports.NQL_RuleTree = void 0;
 const bucket_model_schema_1 = require("../model/bucket_model.schema");
 const string_1 = require("../../../../engine/util/string");
+/**
+ * @category NQL
+ * */
 class NQL_RuleTree {
     constructor(module, bucketName, query, debug = false) {
         this.module = module;
@@ -441,6 +444,9 @@ NQL_RuleTree.OpByType = {
 /**
  * Builds a NQL_CompiledQuery by splitting it into multiple parts
  */
+/**
+ * @category NQL
+ * */
 class NQL_Compiler {
     static build(module, bucketName, query) {
         const tree = new NQL_RuleTree(module, bucketName, query);
@@ -604,6 +610,9 @@ exports.NQL_Compiler = NQL_Compiler;
  * A query ready to be run by the NQL engine, which will call
  * each NQLRunner with a different adapter
  */
+/**
+ * @category NQL
+ * */
 class NQL_CompiledQuery {
     constructor(parts) {
         this.parts = {};

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

@@ -10,9 +10,15 @@ export type NQL_Result<T = Obj> = {
     page?: number;
     perPage?: number;
 };
+/**
+ * @category NQL
+ * */
 export declare abstract class NQLRunner {
     abstract run(trx: AnyTrxNode, part: NQL_Part, params: Record<string, any>, pagination?: NQL_Pagination): Promise<NQL_Result>;
 }
+/**
+ * @category NQL
+ * */
 export declare class NQL_Engine {
     private module;
     private runners;

package/lib/elements/entities/bucket/query/nql_engine.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NQL_Engine = exports.NQLRunner = void 0;
+/**
+ * @category NQL
+ * */
 class NQLRunner {
 }
 exports.NQLRunner = NQLRunner;
+/**
+ * @category NQL
+ * */
 class NQL_Engine {
     constructor(module) {
         this.module = module;

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

@@ -4,6 +4,10 @@ import { $BucketGraph } from '../graph/bucket_graph.schema';
 import { BucketViewFieldBuilderTree, BucketViewFieldFactory } from './bucket_view_field.builder';
 import { $Bucket } from '../bucket.schema';
 import { $Module, $Space } from "../../..";
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class BucketViewBuilder<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
     private name;
     private _fields;

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

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketViewBuilder = void 0;
 const bucket_view_schema_1 = require("./bucket_view.schema");
 const bucket_view_field_builder_1 = require("./bucket_view_field.builder");
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class BucketViewBuilder {
     constructor(name) {
         this.name = name;

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

@@ -2,6 +2,10 @@ import { NesoiObj } from "../../../../engine/data/obj";
 import { Bucket } from '../bucket';
 import { $BucketView } from './bucket_view.schema';
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 export declare class BucketView<$ extends $BucketView> {
     private bucket;
     schema: $;

package/lib/elements/entities/bucket/view/bucket_view.js

@@ -7,6 +7,10 @@ exports.BucketView = void 0;
 const promise_1 = __importDefault(require("../../../../engine/util/promise"));
 const tree_1 = require("../../../../engine/data/tree");
 const error_1 = require("../../../../engine/data/error");
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 class BucketView {
     constructor(bucket, schema) {
         this.bucket = bucket;
@@ -70,10 +74,14 @@ class BucketView {
                 const value = prop.value.drive;
                 const model = tree_1.Tree.get(raw, value.path);
                 if (Array.isArray(model)) {
-                    parsedObj[k] = await bucket.drive.public(model);
+                    const public_urls = [];
+                    for (const obj of model) {
+                        public_urls.push(await bucket.drive.public(obj));
+                    }
+                    parsedObj[k] = public_urls;
                 }
                 else {
-                    parsedObj[k] = (await bucket.drive.public([model]))[0];
+                    parsedObj[k] = (await bucket.drive.public(model));
                 }
             }
             // Group props

package/lib/elements/entities/bucket/view/bucket_view.schema.d.ts

@@ -26,6 +26,10 @@ export type $BucketViewFieldValue = {
     };
     group?: {};
 };
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $BucketViewField {
     name: string;
     scope: 'model' | 'graph' | 'computed' | 'group' | 'view' | 'drive';
@@ -45,6 +49,10 @@ export type $BucketViewFields = {
 export type $BucketViewFieldTree = {
     [x: string]: $BucketViewField | $BucketViewFieldTree;
 };
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $BucketView {
     name: string;
     fields: $BucketViewFields;

package/lib/elements/entities/bucket/view/bucket_view.schema.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$BucketView = exports.$BucketViewField = void 0;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $BucketViewField {
     constructor(name, scope, type, alias, array, required, value, children) {
         this.name = name;
@@ -15,6 +19,10 @@ class $BucketViewField {
     }
 }
 exports.$BucketViewField = $BucketViewField;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $BucketView {
     constructor(name, fields = {}) {
         this.name = name;

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

@@ -12,6 +12,10 @@ type DriveFieldpath<Bucket extends $Bucket> = {
 }[keyof Bucket['#fieldpath']];
 type GraphLinkBucket<Bucket extends $Bucket, L extends keyof Bucket['graph']['links']> = Bucket['graph']['links'][L]['#bucket'];
 type ComputedData<Fn extends $BucketViewFieldFn<any, any>, R = ReturnType<Fn>> = R extends Promise<infer X> ? X : R;
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class BucketViewFieldFactory<Space extends $Space, Module extends $Module, Bucket extends $Bucket> {
     private _view;
     protected scope: $BucketViewField['scope'];
@@ -26,6 +30,10 @@ export declare class BucketViewFieldFactory<Space extends $Space, Module extends
     extend<ViewName extends keyof Bucket['views'], Builders extends BucketViewFieldBuilderTree>(view: ViewName, fields: Builders): $BucketViewFieldBuilderInfer<Bucket["views"][ViewName]["#data"]> & Builders;
     static group(name: string, children: $BucketViewFields): $BucketViewField;
 }
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class BucketViewFieldBuilder<Data, Scope extends $BucketViewField['scope'], GraphLink extends string = never> {
     protected scope: $BucketViewField['scope'];
     protected value: $BucketViewFieldValue;

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

@@ -8,6 +8,10 @@ const bucket_model_convert_1 = require("../model/bucket_model.convert");
 /*
     Factory
 */
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class BucketViewFieldFactory {
     constructor(_view) {
         this._view = _view;
@@ -62,6 +66,10 @@ exports.BucketViewFieldFactory = BucketViewFieldFactory;
 /*
     Builder
 */
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class BucketViewFieldBuilder {
     constructor(scope, value, extra) {
         this.scope = scope;

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

@@ -1,8 +1,9 @@
 import { ResolvedBuilderNode } from "../../../engine/dependency";
 import { $ConstantEnum, $ConstantEnumOption, $ConstantValue, $Constants } from './constants.schema';
 /**
- * Value
- */
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class ConstantValueBuilder {
     private scope;
     private key?;
@@ -10,24 +11,37 @@ export declare class ConstantValueBuilder {
     constructor(scope: string, key?: string | undefined, value?: any | undefined);
     static build(key: string, builder: ConstantValueBuilder): $ConstantValue;
 }
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class ConstantValueFactory {
     static<T>(value: T): ConstantValueBuilder;
     app<T>(key?: string): ConstantValueBuilder;
 }
 type ConstantValueDef = ($: ConstantValueFactory) => Record<string, ConstantValueBuilder>;
 /**
- * Enum
- */
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class ConstantEnumOptionBuilder {
     private value;
     constructor(value: any);
     static build(key: string, builder: ConstantEnumOptionBuilder): $ConstantEnumOption;
 }
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class ConstantEnumOptionFactory<T> {
     opt(value: T): ConstantEnumOptionBuilder;
 }
 type ConstantEnumOptionBuilders = Record<string, ConstantEnumOptionBuilder>;
 type ConstantEnumOptionDef<T> = ($: ConstantEnumOptionFactory<T>) => ConstantEnumOptionBuilders;
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class ConstantEnumBuilder {
     name: string;
     options: ConstantEnumOptionBuilders;
@@ -36,8 +50,9 @@ export declare class ConstantEnumBuilder {
     private static buildOptions;
 }
 /**
- * Constants
- */
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class ConstantsBuilder {
     private module;
     $b: "constants";

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

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstantsBuilder = exports.ConstantEnumBuilder = exports.ConstantEnumOptionFactory = exports.ConstantEnumOptionBuilder = exports.ConstantValueFactory = exports.ConstantValueBuilder = void 0;
 const constants_schema_1 = require("./constants.schema");
 /**
- * Value
- */
+ * @category Builders
+ * @subcategory Entity
+ * */
 class ConstantValueBuilder {
     constructor(scope, key, value) {
         this.scope = scope;
@@ -17,6 +18,10 @@ class ConstantValueBuilder {
     }
 }
 exports.ConstantValueBuilder = ConstantValueBuilder;
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class ConstantValueFactory {
     static(value) {
         return new ConstantValueBuilder('static', undefined, value);
@@ -27,8 +32,9 @@ class ConstantValueFactory {
 }
 exports.ConstantValueFactory = ConstantValueFactory;
 /**
- * Enum
- */
+ * @category Builders
+ * @subcategory Entity
+ * */
 class ConstantEnumOptionBuilder {
     constructor(value) {
         this.value = value;
@@ -39,12 +45,20 @@ class ConstantEnumOptionBuilder {
     }
 }
 exports.ConstantEnumOptionBuilder = ConstantEnumOptionBuilder;
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class ConstantEnumOptionFactory {
     opt(value) {
         return new ConstantEnumOptionBuilder(value);
     }
 }
 exports.ConstantEnumOptionFactory = ConstantEnumOptionFactory;
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class ConstantEnumBuilder {
     constructor(name, options) {
         this.name = name;
@@ -64,8 +78,9 @@ class ConstantEnumBuilder {
 }
 exports.ConstantEnumBuilder = ConstantEnumBuilder;
 /**
- * Constants
- */
+ * @category Builders
+ * @subcategory Entity
+ * */
 class ConstantsBuilder {
     constructor(module) {
         this.module = module;

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

@@ -1,4 +1,8 @@
 import { $ConstantEnum } from './constants.schema';
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 export declare class Enum<$ extends $ConstantEnum> {
     private schema;
     constructor(schema: $);

package/lib/elements/entities/constants/constants.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Enum = void 0;
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 class Enum {
     constructor(schema) {
         this.schema = schema;

package/lib/elements/entities/constants/constants.schema.d.ts

@@ -1,17 +1,29 @@
 import { $Module, $Space } from "../../../schema";
 import { $Message } from '../message/message.schema';
 import { MergeUnion } from "../../../engine/util/type";
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $ConstantValue {
     scope: string;
     key: string;
     value?: any | undefined;
     constructor(scope: string, key: string, value?: any | undefined);
 }
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $ConstantEnumOption {
     key: string;
     value: unknown;
     constructor(key: string, value: unknown);
 }
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $ConstantEnum {
     name: string;
     options: Record<string, $ConstantEnumOption>;
@@ -20,6 +32,10 @@ export declare class $ConstantEnum {
     static keys(schema: $ConstantEnum): string[];
     static get(schema: $ConstantEnum, key: string): unknown;
 }
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $Constants {
     name: string;
     values: Record<string, $ConstantValue>;