nesoi 3.0.8 → 3.0.9

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>;

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

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$Constants = exports.$ConstantEnum = exports.$ConstantEnumOption = exports.$ConstantValue = void 0;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $ConstantValue {
     constructor(scope, key, value) {
         this.scope = scope;
@@ -9,6 +13,10 @@ class $ConstantValue {
     }
 }
 exports.$ConstantValue = $ConstantValue;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $ConstantEnumOption {
     constructor(key, value) {
         this.key = key;
@@ -16,6 +24,10 @@ class $ConstantEnumOption {
     }
 }
 exports.$ConstantEnumOption = $ConstantEnumOption;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $ConstantEnum {
     constructor(name, options) {
         this.name = name;
@@ -29,6 +41,10 @@ class $ConstantEnum {
     }
 }
 exports.$ConstantEnum = $ConstantEnum;
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $Constants {
     constructor(name, values = {}, enums = {}) {
         this.name = name;

package/lib/elements/entities/drive/drive_adapter.d.ts

@@ -3,17 +3,21 @@ export type DriveAdapterConfig = {
     hashAlgorithm?: 'sha1' | 'md5' | 'sha256';
     maxsize?: number;
 };
+/**
+ * @category Adapters
+ * @subcategory Entity
+ * */
 export declare abstract class DriveAdapter {
-    dirpath: string;
     config: DriveAdapterConfig;
-    constructor(dirpath: string, config?: DriveAdapterConfig);
+    constructor(config?: DriveAdapterConfig);
     /**
      * Return a public reference to the file as a string, which
      *  can be used outside the application to reach it.
      *
-     * @returns A `string` which publicly refers to the file
+     * @param filename An optional filename to use on Content-Disposition header
+     * @returns A list of `string` which publicly refers to the files
      */
-    abstract public(remoteFile: NesoiFile[]): Promise<string[]>;
+    abstract public(remoteFile: NesoiFile, filename?: string): Promise<string>;
     /**
      * Read one file from the Drive, given a NesoiFile specifier.
      *
@@ -25,20 +29,21 @@ export declare abstract class DriveAdapter {
      */
     abstract delete(remoteFile: NesoiFile): Promise<void>;
     /**
-     * Move a file inside the Drive
+     * Move a file within the Drive
      */
     abstract move(remoteFile: NesoiFile, newRemotePath: string): Promise<void>;
     /**
      * Create a new file on the Drive, from the contents.
      *
-     * @returns A new `NesoiFile` which refers to the Drive
+     * @returns A new `NesoiFile` referencing a file on the Drive
      */
-    abstract new(filepath: string, data: string | NodeJS.ArrayBufferView): Promise<NesoiFile>;
+    abstract new(filename: string, data: string | NodeJS.ArrayBufferView, dirpath?: string): Promise<NesoiFile>;
     /**
      * Copy a local file to the Drive
-     * - Fails if a file with the same name exists on the target dirpath of the Drive
+     * - Should fail if a file with the same name exists on the target dirpath of the Drive
+     * - Should preserve originalFilename, extname and mimetype
      *
-     * @returns A new `NesoiFile` which refers to the Drive
+     * @returns A new `NesoiFile` referencing a file on the Drive
      */
-    abstract copy(localFile: NesoiFile, dirpath: string, newFilename?: string): Promise<NesoiFile>;
+    abstract upload(localFile: NesoiFile, dirpath?: string, newFilename?: string): Promise<NesoiFile>;
 }

package/lib/elements/entities/drive/drive_adapter.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveAdapter = void 0;
+/**
+ * @category Adapters
+ * @subcategory Entity
+ * */
 class DriveAdapter {
-    constructor(dirpath, config = {}) {
-        this.dirpath = dirpath;
+    constructor(config = {}) {
         this.config = config;
     }
 }

package/lib/elements/entities/drive/local.drive_adapter.d.ts

@@ -1,10 +1,16 @@
 import { NesoiFile } from "../../../engine/data/file";
-import { DriveAdapter } from './drive_adapter';
+import { DriveAdapter, DriveAdapterConfig } from './drive_adapter';
+/**
+ * @category Adapters
+ * @subcategory Entity
+ * */
 export declare class LocalDriveAdapter extends DriveAdapter {
-    public(remoteFiles: NesoiFile[]): Promise<string[]>;
+    dirpath: string;
+    constructor(dirpath: string, config?: DriveAdapterConfig);
+    public(remoteFile: NesoiFile): Promise<string>;
     read(remoteFile: NesoiFile): Promise<Buffer>;
     delete(remoteFile: NesoiFile): Promise<void>;
     move(remoteFile: NesoiFile, remotePath: string): Promise<void>;
-    new(filepath: string, data: string | NodeJS.ArrayBufferView): Promise<NesoiFile>;
-    copy(localFile: NesoiFile, dirpath: string): Promise<NesoiFile>;
+    new(filename: string, data: string | NodeJS.ArrayBufferView, dirpath?: string): Promise<NesoiFile>;
+    upload(localFile: NesoiFile, dirpath?: string, newFilename?: string): Promise<NesoiFile>;
 }

package/lib/elements/entities/drive/local.drive_adapter.js

@@ -8,9 +8,17 @@ const file_1 = require("../../../engine/data/file");
 const drive_adapter_1 = require("./drive_adapter");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+/**
+ * @category Adapters
+ * @subcategory Entity
+ * */
 class LocalDriveAdapter extends drive_adapter_1.DriveAdapter {
-    public(remoteFiles) {
-        return Promise.resolve(remoteFiles.map(file => path_1.default.join(process.cwd(), file.filepath)));
+    constructor(dirpath, config) {
+        super(config);
+        this.dirpath = dirpath;
+    }
+    public(remoteFile) {
+        return Promise.resolve('file://' + path_1.default.join(process.cwd(), remoteFile.filepath));
     }
     read(remoteFile) {
         return Promise.resolve(fs_1.default.readFileSync(remoteFile.filepath));
@@ -21,14 +29,21 @@ class LocalDriveAdapter extends drive_adapter_1.DriveAdapter {
     move(remoteFile, remotePath) {
         return Promise.resolve(fs_1.default.renameSync(remoteFile.filepath, remotePath));
     }
-    async new(filepath, data) {
-        fs_1.default.writeFileSync(filepath, data);
-        return new file_1.NesoiFile(filepath);
+    async new(filename, data, dirpath) {
+        dirpath = dirpath ? path_1.default.join(this.dirpath, dirpath) : this.dirpath;
+        const remoteFilepath = path_1.default.join(dirpath, filename);
+        fs_1.default.writeFileSync(remoteFilepath, data);
+        return file_1.NesoiFile.local.from(remoteFilepath);
     }
-    async copy(localFile, dirpath) {
-        const remoteFilepath = path_1.default.join(dirpath, localFile.newFilename);
+    async upload(localFile, dirpath, newFilename) {
+        dirpath = dirpath ? path_1.default.join(this.dirpath, dirpath) : this.dirpath;
+        const remoteFilepath = path_1.default.join(dirpath, newFilename || localFile.filename);
         fs_1.default.copyFileSync(localFile.filepath, remoteFilepath);
-        return new file_1.NesoiFile(remoteFilepath, { originalFilename: localFile.originalFilename });
+        return file_1.NesoiFile.local.from(remoteFilepath, {
+            originalFilename: localFile.originalFilename,
+            extname: localFile.extname,
+            mimetype: localFile.mimetype
+        });
     }
 }
 exports.LocalDriveAdapter = LocalDriveAdapter;

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

@@ -4,6 +4,10 @@ import { MessageTemplateDef } from './template/message_template.builder';
 import { $MessageInfer } from './message.infer';
 import { ModuleTree } from "../../../engine/tree";
 import { ResolvedBuilderNode } from "../../../engine/dependency";
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class MessageBuilder<Space extends $Space, Module extends $Module, Message extends $Message = $Message> {
     private module;
     private name;

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

@@ -5,6 +5,10 @@ const message_schema_1 = require("./message.schema");
 const message_template_schema_1 = require("./template/message_template.schema");
 const message_template_builder_1 = require("./template/message_template.builder");
 const message_template_field_builder_1 = require("./template/message_template_field.builder");
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class MessageBuilder {
     constructor(module, name) {
         this.module = module;

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

@@ -1,4 +1,8 @@
 import { $Message as $Message } from './message.schema';
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 export declare class Message<$ extends $Message> {
     $: string;
     private __meta__;

package/lib/elements/entities/message/message.js

@@ -5,6 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Message = void 0;
 const crypto_1 = __importDefault(require("crypto"));
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 class Message {
     constructor(_$, data, sigKey) {
         this.$ = _$;

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

@@ -1,4 +1,8 @@
 import { $MessageTemplate } from './template/message_template.schema';
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $Message {
     module: string;
     name: string;

package/lib/elements/entities/message/message.schema.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$Message = void 0;
 const string_1 = require("../../../engine/util/string");
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 class $Message {
     constructor(module, name, alias, template) {
         this.module = module;

package/lib/elements/entities/message/message_parser.d.ts

@@ -2,6 +2,10 @@ import { AnyTrxNode } from "../../../engine/transaction/trx_node";
 import { RawMessageInput } from "../../../schema";
 import { Message } from './message';
 import { $Message } from './message.schema';
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 export declare class MessageParser<$ extends $Message> {
     schema: $;
     constructor(schema: $);

package/lib/elements/entities/message/message_parser.js

@@ -6,6 +6,10 @@ const error_1 = require("../../../engine/data/error");
 const message_1 = require("./message");
 const log_1 = require("../../../engine/util/log");
 const message_template_parser_1 = require("./template/message_template_parser");
+/**
+ * @category Elements
+ * @subcategory Entity
+ * */
 class MessageParser {
     constructor(schema) {
         this.schema = schema;

package/lib/elements/entities/message/template/message_template.builder.d.ts

@@ -2,6 +2,10 @@ import { $Module, $Space } from "../../../../schema";
 import { $MessageTemplate } from './message_template.schema';
 import { MessageTemplateFieldBuilders, MessageTemplateFieldFactory } from './message_template_field.builder';
 import { ModuleTree } from "../../../../engine/tree";
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 export declare class MessageTemplateBuilder {
     private _fields;
     constructor();

package/lib/elements/entities/message/template/message_template.builder.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageTemplateBuilder = void 0;
 const message_template_schema_1 = require("./message_template.schema");
 const message_template_field_builder_1 = require("./message_template_field.builder");
+/**
+ * @category Builders
+ * @subcategory Entity
+ * */
 class MessageTemplateBuilder {
     constructor() {
         this._fields = {};

package/lib/elements/entities/message/template/message_template.schema.d.ts

@@ -31,6 +31,10 @@ export type $MessageTemplateFieldMeta = {
     msg?: $Dependency;
 };
 export type $MessageTemplateFieldType = $BucketModelFieldType | 'string_or_number' | 'id' | 'msg';
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $MessageTemplateField {
     type: $MessageTemplateFieldType;
     name: string;
@@ -52,8 +56,13 @@ export declare class $MessageTemplateField {
 export type $MessageTemplateFields = {
     [x: string]: $MessageTemplateField;
 };
+/**
+ * @category Schemas
+ * @subcategory Entity
+ * */
 export declare class $MessageTemplate {
     fields: $MessageTemplateFields;
     $t: string;
     constructor(fields?: $MessageTemplateFields);
+    static fieldsOfType(template: $MessageTemplate, type: $MessageTemplateFieldType): $MessageTemplateField[];
 }