@webda/core 1.6.0-beta.3 → 2.0.0-beta.2

package/lib/services/binary.d.ts

@@ -9,20 +9,22 @@ import { Service, ServiceParameters } from "./service";
  * Represent basic EventBinary
  */
 export interface EventBinary {
-    object: BinaryMap;
+    object: BinaryFileInfo;
     service: Binary;
-}
-/**
- * Emitted when someone download a binary
- */
-export interface EventBinaryGet extends EventBinary {
+    /**
+     * In case the Context is known
+     */
+    context?: Context;
 }
 export interface EventBinaryUploadSuccess extends EventBinary {
     target: CoreModel;
 }
-export interface EventBinaryDelete extends EventBinary {
-}
-export interface EventBinaryCreate extends EventBinaryUploadSuccess {
+/**
+ * Sent before metadata are updated to allow alteration of the modification
+ */
+export interface EventBinaryMetadataUpdate extends EventBinaryUploadSuccess {
+    target: CoreModel;
+    metadata: BinaryMetadata;
 }
 /**
  * Emitted if binary does not exist
@@ -30,22 +32,42 @@ export interface EventBinaryCreate extends EventBinaryUploadSuccess {
 export declare class BinaryNotFoundError extends WebdaError {
     constructor(hash: string, storeName: string);
 }
-/**
- * Represent a file to store
- */
-export interface BinaryFile {
+export interface BinaryFileInfo {
     /**
-     * Path on the hard drive
+     * Hash of the binary
      */
-    path?: string;
+    hash?: string;
     /**
-     * Content
+     * Will be computed by the service
+     *
+     * hash of the content prefixed by 'WEBDA'
+     */
+    challenge?: string;
+    /**
+     * Size of the file
+     */
+    size: number;
+    /**
+     * Name of the file
      */
-    buffer?: Buffer;
+    name: string;
+    /**
+     * Mimetype
+     */
+    mimetype: string;
+    /**
+     * Metadatas stored along with the binary
+     */
+    metadata?: BinaryMetadata;
+}
+/**
+ * Represent a file to store
+ */
+export declare abstract class BinaryFile implements BinaryFileInfo {
     /**
      * Current name
      */
-    name?: string;
+    name: string;
     /**
      * Original name
      */
@@ -53,11 +75,11 @@ export interface BinaryFile {
     /**
      * Size of the binary
      */
-    size?: number;
+    size: number;
     /**
      * Mimetype of the binary
      */
-    mimetype?: string;
+    mimetype: string;
     /**
      * Will be computed by the service
      *
@@ -70,13 +92,61 @@ export interface BinaryFile {
      * hash of the content
      */
     hash?: string;
+    /**
+     * Metadatas stored along with the binary
+     */
+    metadata?: BinaryMetadata;
+    constructor(info: BinaryFileInfo);
+    /**
+     * Retrieve a plain BinaryFileInfo object
+     * @returns
+     */
+    toBinaryFileInfo(): BinaryFileInfo;
+    abstract get(): Promise<Readable>;
+    /**
+     * Create hashes
+     * @param buffer
+     * @returns
+     */
+    getHashes(): Promise<{
+        hash: string;
+        challenge: string;
+    }>;
 }
+export declare class LocalBinaryFile extends BinaryFile {
+    /**
+     * Path on the hard drive
+     */
+    path: string;
+    constructor(filePath: string);
+    /**
+     * @override
+     */
+    get(): Promise<Readable>;
+}
+export declare class MemoryBinaryFile extends BinaryFile {
+    /**
+     * Content
+     */
+    buffer: Buffer;
+    constructor(buffer: Buffer, info: BinaryFileInfo);
+    /**
+     * @override
+     */
+    get(): Promise<Readable>;
+}
+/**
+ * Define the metadata for a Binary
+ */
+export declare type BinaryMetadata = {
+    [key: string]: any;
+};
 /**
  * This is a map used to retrieve binary
  *
  * @class BinaryMap
  */
-export declare class BinaryMap {
+export declare class BinaryMap extends BinaryFile {
     /**
      * Current context
      */
@@ -85,19 +155,7 @@ export declare class BinaryMap {
      * Link to the binary store
      */
     __store: Binary;
-    /**
-     * Hash of the binary
-     */
-    hash: string;
-    /**
-     * Size of the file
-     */
-    size: number;
-    /**
-     * Mimetype
-     */
-    mime: string;
-    constructor(service: any, obj: any);
+    constructor(service: Binary, obj: BinaryFileInfo);
     /**
      * Prevent all the attributes starting with '__' to be serialized
      * @returns
@@ -157,10 +215,25 @@ export declare class BinaryParameters extends ServiceParameters {
              * Restrict DELETE
              */
             delete?: boolean;
+            /**
+             * Restrict update of metadata
+             */
+            metadata?: boolean;
         };
     };
-    constructor(params: any, service: Service);
+    constructor(params: any, _service: Service);
 }
+export declare type BinaryEvents = {
+    /**
+     * Emitted when someone download a binary
+     */
+    "Binary.Get": EventBinary;
+    "Binary.UploadSuccess": EventBinaryUploadSuccess;
+    "Binary.MetadataUpdate": EventBinaryMetadataUpdate;
+    "Binary.MetadataUpdated": EventBinaryUploadSuccess;
+    "Binary.Create": EventBinaryUploadSuccess;
+    "Binary.Delete": EventBinary;
+};
 /**
  * This is an abstract service to represent a storage of files
  * The binary allow you to expose this service as HTTP
@@ -184,7 +257,7 @@ export declare class BinaryParameters extends ServiceParameters {
  * @abstract
  * @class Binary
  */
-declare abstract class Binary<T extends BinaryParameters = BinaryParameters> extends Service<T> implements MappingService<BinaryMap> {
+declare abstract class Binary<T extends BinaryParameters = BinaryParameters, E extends BinaryEvents = BinaryEvents> extends Service<T, E> implements MappingService<BinaryMap> {
     _lowercaseMaps: any;
     /**
      * When you store a binary to be able to retrieve it you need to store the information into another object
@@ -206,16 +279,14 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters> ext
      * @param {CoreModel} object The object uuid to get from the store
      * @param {String} property The object property to add the file to
      * @param {Object} file The file by itself
-     * @param {Object} metadatas to add to the binary object
+     * @param {Object} metadata to add to the binary object
      * @emits 'binaryCreate'
      */
-    abstract store(object: CoreModel, property: string, file: BinaryFile, metadatas?: {
-        [key: string]: any;
-    }): Promise<void>;
+    abstract store(object: CoreModel, property: string, file: BinaryFile, metadata?: BinaryMetadata): Promise<void>;
     /**
      * The store can retrieve how many time a binary has been used
      */
-    abstract getUsageCount(hash: any): Promise<number>;
+    abstract getUsageCount(hash: string): Promise<number>;
     /**
      * Delete a binary
      *
@@ -256,15 +327,6 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters> ext
      * @returns
      */
     initModel(obj: any): BinaryMap;
-    /**
-     * Create hashes
-     * @param buffer
-     * @returns
-     */
-    _getHashes(buffer: Buffer): {
-        hash: string;
-        challenge: string;
-    };
     /**
      * Read a stream to a buffer
      *
@@ -272,19 +334,17 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters> ext
      * @returns
      */
     static streamToBuffer(stream: Readable): Promise<Buffer>;
-    /**
-     * Update the BinaryFile
-     * @param file
-     */
-    _prepareInput(file: BinaryFile): void;
     /**
      * Check if a map is defined
      *
      * @param name
      * @param property
      */
-    _checkMap(name: string, property: string): void;
-    uploadSuccess(object: CoreModel, property: string, file: any, metadatas?: any): Promise<void>;
+    protected checkMap(name: string, property: string): void;
+    /**
+     * Ensure events are sent correctly after an upload and update the BinaryFileInfo in targetted object
+     */
+    uploadSuccess(object: CoreModel, property: string, file: BinaryFileInfo): Promise<void>;
     /**
      * Cascade delete the object
      *
@@ -306,20 +366,22 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters> ext
      * @param req
      * @returns
      */
-    _getFile(req: Context): any;
+    _getFile(req: Context): Promise<BinaryFile>;
     /**
-     * Init the Binary system routes
+     * @override
      */
     initRoutes(): void;
+    /**
+     * Init the Binary system routes
+     *
+     * Making sure parameters.expose exists prior
+     */
+    _initRoutes(): void;
     /**
      * Return the name of the service for OpenAPI
      * @returns
      */
     protected getOperationName(): string;
-    /**
-     * This is used to allow subclasses to add more route
-     */
-    _initRoutes(): boolean;
     /**
      * Based on the request parameter verify it match a known mapping
      * @param ctx
@@ -331,14 +393,14 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters> ext
      *
      * @param ctx
      */
-    putRedirectUrl(ctx: Context): Promise<{
+    putRedirectUrl(_ctx: Context): Promise<{
         url: string;
         method?: string;
     }>;
     /**
      * Mechanism to add a data based on challenge
      */
-    httpChallenge(ctx: Context): Promise<void>;
+    httpChallenge(ctx: Context<BinaryFile>): Promise<void>;
     /**
      * Manage the different routes
      * @param ctx