@webda/core 2.4.2 → 3.0.0

package/lib/services/binary.d.ts

@@ -5,18 +5,18 @@ import { Readable } from "stream";
 import { Counter, WebdaError } from "../index.js";
 import { CoreModel } from "../models/coremodel.js";
 import { MappingService, Store } from "../stores/store.js";
-import { Context } from "../utils/context.js";
+import { OperationContext, WebContext } from "../utils/context.js";
 import { Service, ServiceParameters } from "./service.js";
 /**
  * Represent basic EventBinary
  */
 export interface EventBinary {
     object: BinaryFileInfo;
-    service: Binary;
+    service: BinaryService;
     /**
      * In case the Context is known
      */
-    context?: Context;
+    context?: OperationContext;
 }
 export interface EventBinaryUploadSuccess extends EventBinary {
     target: CoreModel;
@@ -31,7 +31,7 @@ export interface EventBinaryMetadataUpdate extends EventBinaryUploadSuccess {
 /**
  * Emitted if binary does not exist
  */
-export declare class BinaryNotFoundError extends WebdaError {
+export declare class BinaryNotFoundError extends WebdaError.CodeError {
     constructor(hash: string, storeName: string);
 }
 export interface BinaryFileInfo {
@@ -62,10 +62,14 @@ export interface BinaryFileInfo {
      */
     metadata?: BinaryMetadata;
 }
+/**
+ * Represent files attached to a model
+ */
+export type BinaryFiles = BinaryFileInfo[];
 /**
  * Represent a file to store
  */
-export declare abstract class BinaryFile implements BinaryFileInfo {
+export declare abstract class BinaryFile<T = any> implements BinaryFileInfo {
     /**
      * Current name
      */
@@ -97,8 +101,13 @@ export declare abstract class BinaryFile implements BinaryFileInfo {
     /**
      * Metadatas stored along with the binary
      */
-    metadata?: BinaryMetadata;
+    metadata?: T;
     constructor(info: BinaryFileInfo);
+    /**
+     * Set the information
+     * @param info
+     */
+    set(info: BinaryFileInfo): void;
     /**
      * Retrieve a plain BinaryFileInfo object
      * @returns
@@ -140,29 +149,22 @@ export declare class MemoryBinaryFile extends BinaryFile {
 /**
  * Define the metadata for a Binary
  */
-export type BinaryMetadata = {
-    [key: string]: any;
-};
+export type BinaryMetadata = any;
 /**
  * This is a map used to retrieve binary
  *
  * @class BinaryMap
  */
-export declare class BinaryMap extends BinaryFile {
+export declare class BinaryMap<T = any> extends BinaryFile<T> {
     /**
      * Current context
      */
-    __ctx: Context;
+    __ctx: OperationContext;
     /**
      * Link to the binary store
      */
-    __store: Binary;
-    constructor(service: Binary, obj: BinaryFileInfo);
-    /**
-     * Prevent all the attributes starting with '__' to be serialized
-     * @returns
-     */
-    toJSON(): {};
+    __store: BinaryService;
+    constructor(service: BinaryService, obj: BinaryFileInfo);
     /**
      * Get the binary data
      *
@@ -181,20 +183,104 @@ export declare class BinaryMap extends BinaryFile {
      * Set the http context
      * @param ctx
      */
-    setContext(ctx: Context): void;
+    setContext(ctx: OperationContext): void;
+}
+/**
+ * One Binary instance
+ */
+export declare class Binary<T = any> extends BinaryMap<T> {
+    protected model: CoreModel;
+    protected attribute: string;
+    constructor(attribute: string, model: CoreModel);
+    /**
+     * Replace the binary
+     * @param id
+     * @param ctx
+     * @returns
+     */
+    upload(file: BinaryFile): Promise<void>;
+    /**
+     * Delete the binary, if you need to replace just use upload
+     */
+    delete(): Promise<void>;
+    /**
+     * Return undefined if no hash
+     * @returns
+     */
+    toJSON(): this;
 }
+/**
+ * Define a Binary map stored in a Binaries collection
+ */
+export declare class BinariesItem<T = any> extends BinaryMap<T> {
+    protected parent: BinariesImpl;
+    constructor(parent: BinariesImpl, info: BinaryFileInfo);
+    /**
+     * Replace the binary
+     * @param id
+     * @param ctx
+     * @returns
+     */
+    upload(file: BinaryFile): Promise<void>;
+    /**
+     * Delete the binary, if you need to replace just use upload
+     */
+    delete(): Promise<void>;
+}
+/**
+ * Define a collection of Binary
+ */
+export declare class BinariesImpl<T = any> extends Array<BinariesItem<T>> {
+    __service: BinaryService;
+    protected model: CoreModel;
+    protected attribute: string;
+    assign(model: CoreModel, attribute: string): this;
+    pop(): BinariesItem<T>;
+    slice(): BinariesItem<T>[];
+    unshift(): number;
+    shift(): BinariesItem<T>;
+    push(...args: any[]): number;
+    /**
+     * Upload a file to this model
+     * @param file
+     */
+    upload(file: BinaryFile, replace?: BinariesItem): Promise<void>;
+    /**
+     * Delete an item
+     * @param item
+     */
+    delete(item: BinariesItem): Promise<void>;
+}
+/**
+ * Define a collection of Binary with a Readonly and the upload method
+ */
+export type Binaries = Readonly<Array<BinariesItem>> & {
+    upload: (file: BinaryFile) => Promise<void>;
+};
 export declare class BinaryParameters extends ServiceParameters {
     /**
      * Define the map to Object collection
      *
      * key is a Store name
      * the string[] represent all valids attributes to store files in
+     * @deprecated
      */
     map: {
         [key: string]: string[];
     };
+    /**
+     * Define the map of models
+     * * indicates all models
+     *
+     * key is a Store name
+     * the string[] represent all valids attributes to store files in * indicates all attributes
+     */
+    models: {
+        [key: string]: string[];
+    };
     /**
      * Expose the service to http
+     * @deprecated will be removed in 4.0
      */
     expose?: {
         /**
@@ -236,6 +322,12 @@ export type BinaryEvents = {
     "Binary.Create": EventBinaryUploadSuccess;
     "Binary.Delete": EventBinary;
 };
+/**
+ * Define a BinaryModel with infinite field for binary map
+ */
+export type BinaryModel<T = {
+    [key: string]: BinaryMap[];
+}> = CoreModel & T;
 /**
  * This is an abstract service to represent a storage of files
  * The binary allow you to expose this service as HTTP
@@ -257,9 +349,9 @@ export type BinaryEvents = {
  *
  * @exports
  * @abstract
- * @class Binary
+ * @WebdaModda Binary
  */
-declare abstract class Binary<T extends BinaryParameters = BinaryParameters, E extends BinaryEvents = BinaryEvents> extends Service<T, E> implements MappingService<BinaryMap> {
+export declare abstract class BinaryService<T extends BinaryParameters = BinaryParameters, E extends BinaryEvents = BinaryEvents> extends Service<T, E> implements MappingService<BinaryMap> {
     _lowercaseMaps: any;
     metrics: {
         upload: Counter;
@@ -271,6 +363,13 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters, E e
      * @override
      */
     initMetrics(): void;
+    /**
+     * Define if binary is managed by the store
+     * @param modelName
+     * @param attribute
+     * @returns -1 if not managed, 0 if managed but by default, 1 if managed and in the map, 2 if explicit with attribute and model
+     */
+    handleBinary(modelName: string, attribute: string): -1 | 0 | 1 | 2;
     /**
      * When you store a binary to be able to retrieve it you need to store the information into another object
      *
@@ -307,7 +406,7 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters, E e
      * @param {Number} index The index of the file to change in the property
      * @emits 'binaryDelete'
      */
-    abstract delete(object: CoreModel, property: string, index: number): Promise<void>;
+    abstract delete(object: CoreModel, property: string, index?: number): Promise<void>;
     /**
      * Get a binary
      *
@@ -352,11 +451,11 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters, E e
      * @param name
      * @param property
      */
-    protected checkMap(name: string, property: string): void;
+    protected checkMap(name: string, property: string, modelName?: 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>;
+    uploadSuccess(object: BinaryModel, property: string, file: BinaryFileInfo): Promise<void>;
     /**
      * Cascade delete the object
      *
@@ -372,13 +471,13 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters, E e
      * @param index
      * @returns
      */
-    deleteSuccess(object: CoreModel, property: string, index: number): Promise<void>;
+    deleteSuccess(object: BinaryModel, property: string, index?: number): Promise<any>;
     /**
      * Get file either from multipart post or raw
      * @param req
      * @returns
      */
-    _getFile(req: Context): Promise<BinaryFile>;
+    _getFile(req: WebContext): Promise<BinaryFile>;
     /**
      * @override
      */
@@ -399,24 +498,26 @@ declare abstract class Binary<T extends BinaryParameters = BinaryParameters, E e
      * @param ctx
      * @returns
      */
-    _verifyMapAndStore(ctx: Context): Store<CoreModel>;
+    _verifyMapAndStore(ctx: WebContext): Store<CoreModel>;
     /**
      * By default no challenge is managed so throws 404
      *
      * @param ctx
      */
-    putRedirectUrl(_ctx: Context): Promise<{
+    putRedirectUrl(_ctx: WebContext): Promise<{
         url: string;
         method?: string;
+        headers?: {
+            [key: string]: string;
+        };
     }>;
     /**
      * Mechanism to add a data based on challenge
      */
-    httpChallenge(ctx: Context<BinaryFile>): Promise<void>;
+    httpChallenge(ctx: WebContext<BinaryFile>): Promise<void>;
     /**
      * Manage the different routes
      * @param ctx
      */
-    httpRoute(ctx: Context): Promise<void>;
+    httpRoute(ctx: WebContext): Promise<void>;
 }
-export { Binary };