@webda/core 4.0.0-beta.2 → 4.0.0-beta.3

package/lib/services/binary.service.js

@@ -0,0 +1,1365 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as mime from "mime-types";
+import * as path from "path";
+import { Readable } from "stream";
+import * as WebdaError from "../errors/errors.js";
+import { Service } from "./service.js";
+import { NotEnumerable } from "@webda/tsc-esm";
+import { useCore, useModelMetadata } from "../core/hooks.js";
+import { ServiceParameters } from "./serviceparameters.js";
+import { Counter } from "../metrics/metrics.js";
+import { WEBDA_STORAGE } from "@webda/models";
+import { streamToBuffer, FileSize } from "@webda/utils";
+import { Action } from "../models/decorator.js";
+import { useContext } from "../contexts/execution.js";
+import { WebContext } from "../contexts/webcontext.js";
+/**
+ * Emitted if binary does not exist
+ */
+export class BinaryNotFoundError extends WebdaError.CodeError {
+    /** Create a new BinaryNotFoundError
+     * @param hash - the binary hash
+     * @param storeName - the binary service name
+     */
+    constructor(hash, storeName) {
+        super("BINARY_NOTFOUND", `Binary not found ${hash} BinaryService(${storeName})`);
+    }
+}
+/**
+ * Represent a file to store
+ * @WebdaSchema
+ */
+export class BinaryFile {
+    /**
+     * Current name
+     */
+    name;
+    /**
+     * Original name
+     */
+    originalname;
+    /**
+     * Size of the binary
+     */
+    size;
+    /**
+     * Mimetype of the binary
+     */
+    mimetype;
+    /**
+     * Will be computed by the service
+     *
+     * hash of the content prefixed by 'WEBDA'
+     */
+    challenge;
+    /**
+     * Will be computed by the service
+     *
+     * hash of the content
+     */
+    hash;
+    /**
+     * Metadatas stored along with the binary
+     */
+    metadata;
+    /** Create a new BinaryFile
+     * @param info - the binary file information
+     */
+    constructor(info) {
+        this.set(info);
+    }
+    /**
+     * Set the information
+     * @param info - the information object
+     */
+    set(info) {
+        this.name = info.name;
+        this.challenge = info.challenge;
+        this.hash = info.hash;
+        this.mimetype = info.mimetype || "application/octet-stream";
+        this.metadata = info.metadata || {};
+        this.size = info.size;
+    }
+    /**
+     * Retrieve a plain BinaryFileInfo object
+     * @returns the result
+     */
+    toBinaryFileInfo() {
+        return {
+            hash: this.hash,
+            size: this.size,
+            mimetype: this.mimetype,
+            metadata: this.metadata,
+            challenge: this.challenge,
+            // Fallback on original name
+            name: this.name || this.originalname
+        };
+    }
+    /**
+     * Create hashes
+     * @param buffer - the buffer
+     * @returns the result
+     */
+    async getHashes() {
+        if (!this.hash) {
+            // Using MD5 as S3 content verification use md5
+            const hash = crypto.createHash("md5");
+            const challenge = crypto.createHash("md5");
+            const stream = await this.get();
+            challenge.update("WEBDA");
+            await new Promise((resolve, reject) => {
+                stream.on("error", err => reject(err));
+                stream.on("end", () => {
+                    this.hash = hash.digest("hex");
+                    this.challenge = challenge.digest("hex");
+                    resolve();
+                });
+                stream.on("data", chunk => {
+                    const buffer = Buffer.from(chunk);
+                    hash.update(buffer);
+                    challenge.update(buffer);
+                });
+            });
+        }
+        return {
+            hash: this.hash,
+            challenge: this.challenge
+        };
+    }
+}
+/** BinaryFile backed by a local filesystem path */
+export class LocalBinaryFile extends BinaryFile {
+    /**
+     * Path on the hard drive
+     */
+    path;
+    /** Create a new LocalBinaryFile
+     * @param filePath - path to the local file
+     */
+    constructor(filePath) {
+        super({
+            name: path.basename(filePath),
+            size: fs.statSync(filePath).size,
+            mimetype: mime.lookup(filePath) || "application/octet-stream"
+        });
+        this.path = filePath;
+    }
+    /**
+     * @override
+     */
+    async get() {
+        return fs.createReadStream(this.path);
+    }
+}
+/** BinaryFile backed by an in-memory Buffer */
+let MemoryBinaryFile = (() => {
+    let _classSuper = BinaryFile;
+    let _buffer_decorators;
+    let _buffer_initializers = [];
+    let _buffer_extraInitializers = [];
+    return class MemoryBinaryFile extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _buffer_decorators = [NotEnumerable];
+            __esDecorate(null, null, _buffer_decorators, { kind: "field", name: "buffer", static: false, private: false, access: { has: obj => "buffer" in obj, get: obj => obj.buffer, set: (obj, value) => { obj.buffer = value; } }, metadata: _metadata }, _buffer_initializers, _buffer_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * Content
+         */
+        buffer = __runInitializers(this, _buffer_initializers, void 0);
+        /** Create a new MemoryBinaryFile
+         * @param buffer - the binary content
+         * @param info - optional file information
+         */
+        constructor(buffer, info = {}) {
+            super({
+                ...info,
+                size: info.size || buffer.length,
+                name: info.name || "data.bin",
+                mimetype: info.mimetype || "application/octet-stream"
+            });
+            __runInitializers(this, _buffer_extraInitializers);
+            this.buffer = typeof buffer === "string" ? Buffer.from(buffer) : buffer;
+        }
+        /**
+         * @override
+         */
+        async get() {
+            return Readable.from(this.buffer);
+        }
+    };
+})();
+export { MemoryBinaryFile };
+/**
+ * This is a map used to retrieve binary
+ *
+ * @class BinaryMap
+ */
+export class BinaryMap extends BinaryFile {
+    /**
+     * Link to the binary store
+     */
+    [WEBDA_STORAGE] = {};
+    /** Create a new BinaryMap
+     * @param service - the binary service
+     * @param obj - the binary file information
+     */
+    constructor(service, obj) {
+        super(obj);
+        this.set(obj);
+        this[WEBDA_STORAGE].service = service;
+    }
+    /**
+     * Get the binary data
+     *
+     * @returns the result
+     */
+    get() {
+        return this[WEBDA_STORAGE].service.get(this);
+    }
+    /**
+     * Get into a buffer
+     * @returns the result
+     */
+    async getAsBuffer() {
+        return BinaryService.streamToBuffer(await this.get());
+    }
+    /**
+     * Download the binary to a path
+     *
+     * Shortcut to call {@link Binary.downloadTo} with current object
+     *
+     * @param filename - the filename
+     * @returns the result
+     */
+    async downloadTo(filename) {
+        return this[WEBDA_STORAGE].service.downloadTo(this, filename);
+    }
+}
+/**
+ * One Binary instance — single-cardinality binary attribute on a CoreModel.
+ *
+ * Tagged as a Behavior so the compiler picks it up via the same path as every
+ * other `@WebdaBehavior` class. Its `@Action`-decorated methods are exposed
+ * as model-scoped operations (`<Model>.<Attribute>.<Action>`) and routed by
+ * `RESTOperationsTransport.exposeBehaviorRoutes`.
+ *
+ * Constructor takes no required arguments because the transformer-emitted
+ * `__hydrateBehaviors` calls `new Binary()` with zero args before stamping
+ * the parent reference into `WEBDA_STORAGE["__parent__"]`. Legacy 2-arg
+ * usage (`new Binary(attribute, model)`) is still supported for direct
+ * callers and tests; when present, the constructor eagerly resolves the
+ * service and copies the existing model attribute value so callers can call
+ * `isEmpty()` and `hash`/`size` immediately.
+ *
+ * @readOnly
+ * @WebdaBehavior Webda/Binary
+ */
+let Binary = (() => {
+    let _classSuper = BinaryMap;
+    let _instanceExtraInitializers = [];
+    let _delete_decorators;
+    let _attach_decorators;
+    let _attachChallenge_decorators;
+    let _download_decorators;
+    let _downloadUrl_decorators;
+    let _setMetadata_decorators;
+    return class Binary extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _delete_decorators = [Action({ rest: { route: "{hash}", method: "DELETE" } })];
+            _attach_decorators = [Action({ rest: { route: ".", method: "POST" } })];
+            _attachChallenge_decorators = [Action({ rest: { route: ".", method: "PUT" } })];
+            _download_decorators = [Action({ rest: { route: ".", method: "GET" } })];
+            _downloadUrl_decorators = [Action({ rest: { route: "url", method: "GET" } })];
+            _setMetadata_decorators = [Action({ rest: { route: "{hash}", method: "PUT" } })];
+            __esDecorate(this, null, _delete_decorators, { kind: "method", name: "delete", static: false, private: false, access: { has: obj => "delete" in obj, get: obj => obj.delete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _attach_decorators, { kind: "method", name: "attach", static: false, private: false, access: { has: obj => "attach" in obj, get: obj => obj.attach }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _attachChallenge_decorators, { kind: "method", name: "attachChallenge", static: false, private: false, access: { has: obj => "attachChallenge" in obj, get: obj => obj.attachChallenge }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _download_decorators, { kind: "method", name: "download", static: false, private: false, access: { has: obj => "download" in obj, get: obj => obj.download }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _downloadUrl_decorators, { kind: "method", name: "downloadUrl", static: false, private: false, access: { has: obj => "downloadUrl" in obj, get: obj => obj.downloadUrl }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setMetadata_decorators, { kind: "method", name: "setMetadata", static: false, private: false, access: { has: obj => "setMetadata" in obj, get: obj => obj.setMetadata }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        // NOTE: do NOT redeclare `[WEBDA_STORAGE]` as a field here — class field
+        // initializers in the subclass run AFTER `super()` returns and OVERWRITE
+        // whatever BinaryMap (and BinaryFile before it) stored. We rely on the
+        // inherited `[WEBDA_STORAGE]: { service: BinaryService } = {}` from
+        // BinaryMap and stash the Behavior-specific keys (`empty`, `__parent__`)
+        // through a typed cast at the assignment site.
+        /** Create a new Binary.
+         *
+         * Callable with no arguments (the Behavior-hydration path the transformer
+         * emits) or with the legacy `(attribute, model)` pair for direct
+         * instantiation in tests / non-hydrated code.
+         * @param attribute - the model attribute name (legacy form)
+         * @param model - the parent model (legacy form)
+         */
+        constructor(attribute, model) {
+            // `super()` must be the constructor's first statement, unconditionally.
+            // The decorator runtime injects instance initialisers right after it, and
+            // with `super()` inside `if`/`else` there is nowhere correct to put them:
+            // TypeScript 6 silently dropped them — so `@Action` `addInitializer` hooks
+            // never ran for Binary — and tsgo runs them before `super()`, which throws
+            // ReferenceError on `new Binary()`. TypeScript 6 also drops them when
+            // any statement precedes `super()`, hence the repeated condition.
+            //
+            // Legacy eager wiring resolves the service and loads the existing data, so
+            // callers can use `isEmpty()` / `.hash` / `.size` right away. The hydration
+            // path (no arguments) leaves both unresolved: the generated
+            // `__hydrateBehaviors` stamps `__parent__` afterwards and the public API
+            // resolves the service lazily through `getService()`.
+            super(attribute !== undefined && model !== undefined
+                ? useCore().getBinaryStore(model, attribute)
+                : undefined, attribute !== undefined && model !== undefined ? model[attribute] || {} : {});
+            __runInitializers(this, _instanceExtraInitializers);
+            const eager = attribute !== undefined && model !== undefined;
+            this[WEBDA_STORAGE].empty = eager ? model[attribute] === undefined : true;
+            if (eager)
+                this[WEBDA_STORAGE]["__parent__"] = { instance: model, attribute };
+        }
+        /**
+         * Resolve the BinaryService lazily via the Behavior parent reference.
+         *
+         * The transformer-emitted `__hydrateBehaviors` writes
+         * `WEBDA_STORAGE["__parent__"]` after construction, and the per-Behavior
+         * `parent` getter (also emitted by the transformer) surfaces it as
+         * `this.parent`. We resolve the service on first call and cache it on the
+         * storage slot so subsequent calls don't re-walk the binary registry.
+         *
+         * @returns the BinaryService that owns this Binary's parent attribute
+         */
+        getService() {
+            if (!this[WEBDA_STORAGE].service) {
+                const parent = this.getParent();
+                if (!parent) {
+                    throw new Error("Binary parent not yet wired — cannot resolve BinaryService");
+                }
+                this[WEBDA_STORAGE].service = useCore().getBinaryStore(parent.instance, parent.attribute);
+            }
+            return this[WEBDA_STORAGE].service;
+        }
+        /**
+         * Read the Behavior parent reference. The transformer-emitted `parent`
+         * getter on `@WebdaBehavior` classes returns the same slot, but Binary
+         * may also be used in code paths where the transformer hasn't run (e.g.
+         * unit tests that hand-roll instances), so we read the slot directly.
+         *
+         * @returns the parent reference or undefined
+         */
+        getParent() {
+            return this[WEBDA_STORAGE]["__parent__"];
+        }
+        /**
+         * isEmpty
+         * @returns the result
+         */
+        isEmpty() {
+            return this[WEBDA_STORAGE].empty;
+        }
+        /**
+         * Ensure empty is set correctly.
+         *
+         * `BinaryFile`'s constructor calls `this.set(info)` before subclass class-field
+         * initializers run, so `this[WEBDA_STORAGE]` is still `undefined` the first
+         * time we get here when constructing a fresh `new Binary()` (the no-args
+         * path used by the transformer's `__hydrateBehaviors`). Initialize the
+         * slot lazily on the first set call to keep that boot path crash-free —
+         * the class-field initializer on `BinaryMap` will then OVERWRITE this on
+         * its way back from super, but that's fine because it preserves the
+         * shape `{ service?, empty?, ... }` and we've passed through `set` only
+         * once at this point.
+         *
+         * @param info - the information object
+         */
+        set(info) {
+            super.set(info);
+            const slot = (this[WEBDA_STORAGE] ??= {});
+            slot.empty = false;
+        }
+        /**
+         * Replace the binary by uploading a new file. Direct programmatic use
+         * (non-HTTP). Equivalent to the `attach(...)` HTTP action minus the
+         * context handling.
+         * @param file - the binary file to upload
+         * @returns the result
+         */
+        async upload(file) {
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binary parent not yet wired — cannot upload");
+            }
+            await this.getService().store(parent.instance, parent.attribute, file);
+            this.set(file);
+        }
+        /**
+         * Delete this binary from storage and clear local state.
+         *
+         * Exposed as a Behavior `@Action` (DELETE on `{uuid}/<attribute>/{hash}`).
+         * The URL `{hash}` must match the current binary's hash; this guards
+         * against accidental deletes when the client raced a metadata update.
+         *
+         * Migrated from `DomainService.binaryAction` (action="delete",
+         * single-cardinality branch).
+         * @param hash - the URL-supplied hash; must match `this.hash`
+         */
+        async delete(hash) {
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binary parent not yet wired — cannot delete");
+            }
+            if (!this.hash || this.hash !== hash) {
+                throw new WebdaError.BadRequest("Hash does not match");
+            }
+            await this.getService().delete(parent.instance, parent.attribute);
+            this.set({});
+            this[WEBDA_STORAGE].empty = true;
+        }
+        /**
+         * Direct (multipart / raw) upload from an HTTP request.
+         *
+         * `POST /<plural>/{uuid}/<attribute>` — accepts the binary content as the
+         * request body, hashes it, stores it on the BinaryService, and updates
+         * this Binary's metadata. Returns early if the new content's hash matches
+         * what we already hold (idempotent on duplicate uploads).
+         *
+         * Migrated from `DomainService.binaryPut`; the parent-loading step is
+         * unnecessary here because the Behavior is already attached to its parent
+         * by `__hydrateBehaviors`.
+         */
+        async attach() {
+            const context = useContext();
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binary parent not yet wired — cannot attach");
+            }
+            const service = this.getService();
+            const file = await service.getFile(context);
+            const { hash } = await file.getHashes();
+            if (this.hash === hash) {
+                return; // already linked — idempotent
+            }
+            await service.store(parent.instance, parent.attribute, file);
+            this.set(file);
+        }
+        /**
+         * Challenge-based upload handshake.
+         *
+         * `PUT /<plural>/{uuid}/<attribute>` — the client sends `{ hash, challenge,
+         * size?, name?, mimetype?, metadata? }`; we ask the BinaryService for a
+         * pre-signed upload URL (or a "done" flag if dedup matched) and return it.
+         *
+         * Migrated from `DomainService.binaryChallenge`.
+         * @param body - the challenge body forwarded by `resolveArguments`; falls
+         *   back to `context.getInput()` when undefined.
+         * @returns `{ url?, method?, headers?, done, md5 }`
+         */
+        async attachChallenge(body) {
+            const context = useContext();
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binary parent not yet wired — cannot attachChallenge");
+            }
+            const service = this.getService();
+            if (body === undefined) {
+                body = await context.getInput();
+            }
+            if (this.hash === body.hash) {
+                return; // already linked
+            }
+            const url = await service.putRedirectUrl(parent.instance, parent.attribute, body, context);
+            const md5 = Buffer.from(body.hash, "hex").toString("base64");
+            return {
+                ...url,
+                done: url === undefined,
+                md5
+            };
+        }
+        /**
+         * Stream the binary to the response, or 302-redirect to a signed URL.
+         *
+         * `GET /<plural>/{uuid}/<attribute>` — if the underlying BinaryService
+         * supports redirect URLs (e.g. S3) we 302 to the signed URL; otherwise we
+         * pipe the bytes directly through the response.
+         *
+         * Named `download` (not `get`) so the parent `BinaryMap.get(): Readable`
+         * accessor isn't shadowed — Behavior @Action methods can't change the
+         * parent type's contract, and a plain `get()` overload that returns
+         * `void` would break callers that consume the Readable.
+         *
+         * Migrated from `DomainService.binaryGet` (single-cardinality branch).
+         */
+        async download() {
+            const context = useContext();
+            const service = this.getService();
+            if (!this.hash) {
+                throw new WebdaError.NotFound("Object does not exist or attachment does not exist");
+            }
+            const url = await service.getRedirectUrlFromObject(this, context);
+            if (url === null) {
+                // No redirect — stream directly through the response.
+                context.writeHead(200, {
+                    "Content-Type": this.mimetype === undefined ? "application/octet-stream" : this.mimetype,
+                    "Content-Length": this.size
+                });
+                const readStream = await service.get(this);
+                await new Promise((resolve, reject) => {
+                    context._stream.on("finish", resolve);
+                    context._stream.on("error", reject);
+                    readStream.pipe(context._stream);
+                });
+            }
+            else {
+                context.writeHead(302, { Location: url });
+            }
+        }
+        /**
+         * Return a JSON `{ Location, Map }` describing where to fetch the binary.
+         *
+         * `GET /<plural>/{uuid}/<attribute>/url` — variant of `download()` that
+         * returns the URL as JSON instead of redirecting. Used by clients that
+         * want to discover the URL without following the redirect.
+         *
+         * Migrated from `DomainService.binaryGet`'s `returnUrl` branch.
+         * @returns `{ Location, Map }`
+         */
+        async downloadUrl() {
+            const context = useContext();
+            const service = this.getService();
+            if (!this.hash) {
+                throw new WebdaError.NotFound("Object does not exist or attachment does not exist");
+            }
+            const url = await service.getRedirectUrlFromObject(this, context);
+            if (url === null) {
+                // No service-level signed URL: fall back to the same URL minus `/url`.
+                if (context instanceof WebContext) {
+                    return {
+                        Location: context
+                            .getHttpContext()
+                            .getAbsoluteUrl()
+                            .replace(/\/url$/, ""),
+                        Map: this
+                    };
+                }
+                return { Location: undefined, Map: this };
+            }
+            return { Location: url, Map: this };
+        }
+        /**
+         * Update the metadata sidecar attached to this binary.
+         *
+         * `PUT /<plural>/{uuid}/<attribute>/{hash}` — verifies the URL `{hash}`
+         * matches the current binary, applies the new metadata, and persists via
+         * `parent.instance.patch(...)`. Metadata payload is capped at 4 KB to
+         * mirror the existing `DomainService.binaryAction` rule.
+         *
+         * Migrated from `DomainService.binaryAction` (action="metadata" branch).
+         * @param hash - the URL-supplied hash; must match `this.hash`
+         * @param metadata - the new metadata blob (≤ 4 KB JSON)
+         */
+        async setMetadata(hash, metadata) {
+            const context = useContext();
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binary parent not yet wired — cannot setMetadata");
+            }
+            if (this.hash !== hash) {
+                throw new WebdaError.BadRequest("Hash does not match");
+            }
+            if (metadata === undefined) {
+                metadata = await context.getInput();
+            }
+            if (JSON.stringify(metadata).length >= 4096) {
+                throw new WebdaError.BadRequest("Metadata is too big: 4kb max");
+            }
+            this.metadata = metadata;
+            await parent.instance.patch({
+                [parent.attribute]: this
+            });
+        }
+        /**
+         * Return undefined at runtime if no hash; the type annotation deliberately
+         * narrows to the populated shape so the schema generator follows
+         * `BinaryFileInfo<T>` for the Output/Stored schemas.
+         * @returns the result
+         */
+        toJSON() {
+            if (!this.hash) {
+                return undefined;
+            }
+            return this;
+        }
+        get parent() { return this[WEBDA_STORAGE]["__parent__"]; }
+    };
+})();
+export { Binary };
+/**
+ * Define a Binary map stored in a Binaries collection
+ */
+export class BinariesItem extends BinaryMap {
+    [WEBDA_STORAGE] = {};
+    /** Create a new BinariesItem
+     * @param parent - the parent binaries collection
+     * @param info - the binary file information
+     */
+    constructor(parent, info) {
+        super(parent[WEBDA_STORAGE].service, info);
+        this[WEBDA_STORAGE].parent = parent;
+    }
+    /**
+     * Replace the binary
+     * @param id - the identifier
+     * @param ctx - the operation context
+     * @param file - the file path
+     * @returns the result
+     */
+    async upload(file) {
+        await this[WEBDA_STORAGE].parent.upload(file, this);
+        this.set(file);
+    }
+    /**
+     * Delete the binary, if you need to replace just use upload
+     * @returns the result
+     */
+    async delete() {
+        return this[WEBDA_STORAGE].parent.delete(this);
+    }
+}
+/**
+ * Define a collection of Binary — many-cardinality binary attribute.
+ *
+ * Tagged as a Behavior so its `@Action` methods register as
+ * `<Model>.<Attribute>.<Action>` operations alongside Single-Binary ones.
+ * Inherits from `Array<BinariesItem<T>>` so it preserves array semantics
+ * (iteration, indexed access, JSON.stringify-as-array). The transformer
+ * detects this Array-subclass shape and emits a push-based hydration
+ * coercion — see `behaviors.ts:createHydrationBlock`.
+ *
+ * @readOnly
+ * @WebdaBehavior Webda/BinariesImpl
+ */
+let BinariesImpl = (() => {
+    let _classSuper = Array;
+    let _instanceExtraInitializers = [];
+    let _attach_decorators;
+    let _attachChallenge_decorators;
+    let _get_decorators;
+    let _getUrl_decorators;
+    let _deleteAt_decorators;
+    let _setMetadata_decorators;
+    return class BinariesImpl extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _attach_decorators = [Action({ rest: { route: ".", method: "POST" } })];
+            _attachChallenge_decorators = [Action({ rest: { route: ".", method: "PUT" } })];
+            _get_decorators = [Action({ rest: { route: "{index}", method: "GET" } })];
+            _getUrl_decorators = [Action({ rest: { route: "{index}/url", method: "GET" } })];
+            _deleteAt_decorators = [Action({ rest: { route: "{index}/{hash}", method: "DELETE" } })];
+            _setMetadata_decorators = [Action({ rest: { route: "{index}/{hash}", method: "PUT" } })];
+            __esDecorate(this, null, _attach_decorators, { kind: "method", name: "attach", static: false, private: false, access: { has: obj => "attach" in obj, get: obj => obj.attach }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _attachChallenge_decorators, { kind: "method", name: "attachChallenge", static: false, private: false, access: { has: obj => "attachChallenge" in obj, get: obj => obj.attachChallenge }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _get_decorators, { kind: "method", name: "get", static: false, private: false, access: { has: obj => "get" in obj, get: obj => obj.get }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getUrl_decorators, { kind: "method", name: "getUrl", static: false, private: false, access: { has: obj => "getUrl" in obj, get: obj => obj.getUrl }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteAt_decorators, { kind: "method", name: "deleteAt", static: false, private: false, access: { has: obj => "deleteAt" in obj, get: obj => obj.deleteAt }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setMetadata_decorators, { kind: "method", name: "setMetadata", static: false, private: false, access: { has: obj => "setMetadata" in obj, get: obj => obj.setMetadata }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        [WEBDA_STORAGE] = (__runInitializers(this, _instanceExtraInitializers), {});
+        /**
+         * Bind this collection to a model and attribute, populating from existing binary data.
+         *
+         * Legacy entry-point used by code that constructs a `BinariesImpl()`
+         * directly (tests, manual instantiation). The Behavior-hydration path the
+         * transformer emits writes `WEBDA_STORAGE["__parent__"]` instead and
+         * never calls `assign`.
+         *
+         * @param model - the model to use
+         * @param attribute - the attribute name
+         * @returns this for chaining
+         */
+        assign(model, attribute) {
+            this[WEBDA_STORAGE]["__parent__"] = { instance: model, attribute };
+            for (const binary of model[attribute] || []) {
+                this.push(binary);
+            }
+            this[WEBDA_STORAGE].service = useCore().getBinaryStore(model, attribute);
+            return this;
+        }
+        /**
+         * Resolve the BinaryService lazily via the Behavior parent reference.
+         *
+         * Mirrors `Binary.getService()`. The transformer-emitted parent slot
+         * (`WEBDA_STORAGE["__parent__"]`) is the source of truth.
+         *
+         * @returns the BinaryService for this collection's parent attribute
+         */
+        getService() {
+            if (!this[WEBDA_STORAGE].service) {
+                const parent = this.getParent();
+                if (!parent) {
+                    throw new Error("Binaries parent not yet wired — cannot resolve BinaryService");
+                }
+                this[WEBDA_STORAGE].service = useCore().getBinaryStore(parent.instance, parent.attribute);
+            }
+            return this[WEBDA_STORAGE].service;
+        }
+        /**
+         * Read the Behavior parent reference. Mirrors `Binary.getParent()`.
+         * @returns the parent reference or undefined
+         */
+        getParent() {
+            return this[WEBDA_STORAGE]["__parent__"];
+        }
+        /** @throws Readonly collection */
+        pop() {
+            throw new Error("Readonly");
+        }
+        /** @throws Readonly collection */
+        slice() {
+            throw new Error("Readonly");
+        }
+        /** @throws Readonly collection */
+        unshift() {
+            throw new Error("Readonly");
+        }
+        /** @throws Readonly collection */
+        shift() {
+            throw new Error("Readonly");
+        }
+        /**
+         * Add binary items, wrapping plain objects in BinariesItem
+         * @param args - additional arguments
+         * @returns the result number
+         */
+        push(...args) {
+            return super.push(...args.map(arg => (arg instanceof BinariesItem ? arg : new BinariesItem(this, arg))));
+        }
+        /**
+         * Upload a file to this model. Direct programmatic API (non-HTTP).
+         * @param file - the file path
+         * @param replace - whether to replace existing
+         */
+        async upload(file, replace) {
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binaries parent not yet wired — cannot upload");
+            }
+            await this.getService().store(parent.instance, parent.attribute, file);
+            // Should call the store first
+            super.push(new BinariesItem(this, file));
+            if (replace) {
+                await this.delete(replace);
+            }
+        }
+        /**
+         * Delete an item by reference or index. Direct programmatic API (non-HTTP).
+         * @param item - the item to delete
+         */
+        async delete(item) {
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binaries parent not yet wired — cannot delete");
+            }
+            let itemIndex = this.indexOf(item);
+            if (itemIndex === -1) {
+                throw new Error("Item not found");
+            }
+            await this.getService().delete(parent.instance, parent.attribute, itemIndex);
+            itemIndex = this.indexOf(item);
+            if (itemIndex >= 0) {
+                // Call store delete here
+                this.splice(itemIndex, 1);
+            }
+        }
+        /**
+         * Direct (multipart / raw) upload from an HTTP request. Pushes a new item
+         * onto the collection.
+         *
+         * `POST /<plural>/{uuid}/<attribute>` — same shape as `Binary.attach` but
+         * pushes the new file rather than replacing the existing one.
+         * Migrated from `DomainService.binaryPut` (MANY-cardinality branch).
+         */
+        async attach() {
+            const context = useContext();
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binaries parent not yet wired — cannot attach");
+            }
+            const service = this.getService();
+            const file = await service.getFile(context);
+            const { hash } = await file.getHashes();
+            if (this.find(item => item.hash === hash)) {
+                return; // dedup
+            }
+            await service.store(parent.instance, parent.attribute, file);
+            super.push(new BinariesItem(this, file));
+        }
+        /**
+         * Challenge-based upload handshake for the next item.
+         *
+         * `PUT /<plural>/{uuid}/<attribute>` — request a pre-signed upload URL
+         * for a new item identified by `{ hash, challenge, ... }`. Returns the
+         * URL or a `done` flag if dedup matched.
+         *
+         * Migrated from `DomainService.binaryChallenge` (MANY-cardinality branch).
+         * @param body - the challenge body; falls back to `context.getInput()`
+         * @returns `{ url?, method?, headers?, done, md5 }`
+         */
+        async attachChallenge(body) {
+            const context = useContext();
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binaries parent not yet wired — cannot attachChallenge");
+            }
+            const service = this.getService();
+            if (body === undefined) {
+                body = await context.getInput();
+            }
+            if (this.find(item => item.hash === body.hash)) {
+                return; // dedup
+            }
+            const url = await service.putRedirectUrl(parent.instance, parent.attribute, body, context);
+            const md5 = Buffer.from(body.hash, "hex").toString("base64");
+            return {
+                ...url,
+                done: url === undefined,
+                md5
+            };
+        }
+        /**
+         * Stream a single item to the response, or 302-redirect to a signed URL.
+         *
+         * `GET /<plural>/{uuid}/<attribute>/{index}` — locates the item by `index`
+         * and behaves like `Binary.get` for that single entry.
+         *
+         * Migrated from `DomainService.binaryGet` (MANY-cardinality branch).
+         * @param index - the item position in the collection
+         */
+        async get(index) {
+            const context = useContext();
+            const service = this.getService();
+            const idx = typeof index === "number" ? index : parseInt(index);
+            if (this.length <= idx || idx < 0) {
+                throw new WebdaError.NotFound("Object does not exist or attachment does not exist");
+            }
+            const file = this[idx];
+            const url = await service.getRedirectUrlFromObject(file, context);
+            if (url === null) {
+                context.writeHead(200, {
+                    "Content-Type": file.mimetype === undefined ? "application/octet-stream" : file.mimetype,
+                    "Content-Length": file.size
+                });
+                const readStream = await service.get(file);
+                await new Promise((resolve, reject) => {
+                    context._stream.on("finish", resolve);
+                    context._stream.on("error", reject);
+                    readStream.pipe(context._stream);
+                });
+            }
+            else {
+                context.writeHead(302, { Location: url });
+            }
+        }
+        /**
+         * Return a `{ Location, Map }` JSON for a single item.
+         *
+         * `GET /<plural>/{uuid}/<attribute>/{index}/url` — variant of `get` that
+         * returns the URL as JSON instead of redirecting / streaming.
+         *
+         * Migrated from `DomainService.binaryGet`'s `returnUrl` branch
+         * (MANY-cardinality).
+         * @param index - the item position in the collection
+         * @returns `{ Location, Map }`
+         */
+        async getUrl(index) {
+            const context = useContext();
+            const service = this.getService();
+            const idx = typeof index === "number" ? index : parseInt(index);
+            if (this.length <= idx || idx < 0) {
+                throw new WebdaError.NotFound("Object does not exist or attachment does not exist");
+            }
+            const file = this[idx];
+            const url = await service.getRedirectUrlFromObject(file, context);
+            if (url === null) {
+                if (context instanceof WebContext) {
+                    return {
+                        Location: context
+                            .getHttpContext()
+                            .getAbsoluteUrl()
+                            .replace(/\/url$/, ""),
+                        Map: file
+                    };
+                }
+                return { Location: undefined, Map: file };
+            }
+            return { Location: url, Map: file };
+        }
+        /**
+         * Delete a single item by `(index, hash)`.
+         *
+         * `DELETE /<plural>/{uuid}/<attribute>/{index}/{hash}` — the URL `{hash}`
+         * must match the item at `{index}`. Removes from storage and from the
+         * in-memory collection.
+         *
+         * Migrated from `DomainService.binaryAction` (action="delete",
+         * MANY-cardinality branch).
+         * @param index - the item position
+         * @param hash - the URL-supplied hash; must match `this[index].hash`
+         */
+        async deleteAt(index, hash) {
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binaries parent not yet wired — cannot delete");
+            }
+            const idx = typeof index === "number" ? index : parseInt(index);
+            const file = this[idx];
+            if (!file || file.hash !== hash) {
+                throw new WebdaError.BadRequest("Hash does not match");
+            }
+            await this.getService().delete(parent.instance, parent.attribute, idx);
+            if (this[idx] && this[idx].hash === hash) {
+                this.splice(idx, 1);
+            }
+        }
+        /**
+         * Update the metadata sidecar of a single item.
+         *
+         * `PUT /<plural>/{uuid}/<attribute>/{index}/{hash}` — verifies the hash,
+         * applies the new metadata, and persists via `parent.instance.patch(...)`.
+         * Metadata payload capped at 4 KB.
+         *
+         * Migrated from `DomainService.binaryAction` (action="metadata",
+         * MANY-cardinality branch).
+         * @param index - the item position
+         * @param hash - the URL-supplied hash; must match `this[index].hash`
+         * @param metadata - the new metadata blob (≤ 4 KB JSON)
+         */
+        async setMetadata(index, hash, metadata) {
+            const context = useContext();
+            const parent = this.getParent();
+            if (!parent) {
+                throw new Error("Binaries parent not yet wired — cannot setMetadata");
+            }
+            const idx = typeof index === "number" ? index : parseInt(index);
+            const file = this[idx];
+            if (!file || file.hash !== hash) {
+                throw new WebdaError.BadRequest("Hash does not match");
+            }
+            if (metadata === undefined) {
+                metadata = await context.getInput();
+            }
+            if (JSON.stringify(metadata).length >= 4096) {
+                throw new WebdaError.BadRequest("Metadata is too big: 4kb max");
+            }
+            file.metadata = metadata;
+            await parent.instance.patch({
+                [parent.attribute]: this
+            });
+        }
+        /**
+         * Native array serialization. The transformer adds a Behavior-style
+         * `toJSON` to every Behavior class unless the author defines one;
+         * we override it explicitly so JSON.stringify produces a plain array of
+         * items rather than an object keyed by indices.
+         * @returns the result array
+         */
+        toJSON() {
+            return Array.from(this);
+        }
+        get parent() { return this[WEBDA_STORAGE]["__parent__"]; }
+    };
+})();
+export { BinariesImpl };
+/** Parameters for BinaryService, defining model mappings and max upload size */
+export class BinaryParameters extends ServiceParameters {
+    /**
+     * max file size
+     */
+    _maxFileSize;
+    /**
+     * 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;
+    /**
+     * Define the maximum filesize to accept as direct upload
+     *
+     * @default 10 MB
+     */
+    set maxFileSize(value) {
+        this._maxFileSize = new FileSize(value).valueOf();
+    }
+    /**
+     * Get the max file size in bytes
+     * @returns the result number
+     */
+    get maxFileSize() {
+        return this._maxFileSize;
+    }
+    /**
+     * Load parameters with defaults for model mappings and max file size
+     * @param params - the service parameters
+     * @returns this for chaining
+     */
+    load(params = {}) {
+        super.load(params);
+        // Store all models in it by default
+        this.models ??= {
+            "*": ["*"]
+        };
+        this.maxFileSize = new FileSize(params.maxFileSize ?? "10 MB").valueOf();
+        return this;
+    }
+}
+/**
+ * This is an abstract service to represent a storage of files
+ * The binary allow you to expose this service as HTTP
+ *
+ * It supports two modes:
+ *  - attached to a CoreModel (attach, detach, reattach)
+ *  - pure storage with no managed id (read, write, delete)
+ *
+ * As we have deduplication builtin you can get some stats
+ * - getUsageCount(hash)
+ * - getUsageCountForRaw()
+ * - getUsageCountForMap()
+ *
+ * The Binary storage should store only once a binary and reference every object that are used by this binary, so it can be cleaned.
+ *
+ *
+ * @see FileBinary
+ * @see S3Binary
+ *
+ * @exports
+ * @abstract
+ * @WebdaModda Binary
+ */
+export class BinaryService extends Service {
+    _lowercaseMaps;
+    /**
+     * @override
+     */
+    initMetrics() {
+        super.initMetrics();
+        this.metrics.upload = this.getMetric(Counter, {
+            name: "binary_upload",
+            help: "Number of binary upload"
+        });
+        this.metrics.delete = this.getMetric(Counter, {
+            name: "binary_delete",
+            help: "Number of binary deleted"
+        });
+        this.metrics.download = this.getMetric(Counter, {
+            name: "binary_download",
+            help: "Number of binary upload"
+        });
+        this.metrics.metadataUpdate = this.getMetric(Counter, {
+            name: "binary_metadata_update",
+            help: "Number of binary metadata updated"
+        });
+    }
+    /**
+     * Get a UrlFromObject
+     *
+     * @param binaryMap - the binary map definition
+     * @param _context - the execution context
+     * @param _expires - the expiration time
+     * @returns the result
+     */
+    async getRedirectUrlFromObject(binaryMap, _context, _expires = 30) {
+        return null;
+    }
+    /**
+     * Define if binary is managed by the store
+     * @param modelName - the model name
+     * @param attribute - the attribute name
+     * @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, attribute) {
+        let key = Object.keys(this.parameters.models).find(k => k === modelName);
+        if (key) {
+            // Explicit model
+            const attributes = this.parameters.models[key];
+            if (attributes.includes(attribute)) {
+                return 2;
+            }
+            else if (attributes.includes("*")) {
+                return 1;
+            }
+        }
+        // Default to all model - 593-594,598-599
+        key = Object.keys(this.parameters.models).find(k => k === "*");
+        if (!key) {
+            return -1;
+        }
+        const attributes = this.parameters.models[key];
+        if (attributes.includes(attribute)) {
+            return 1;
+        }
+        if (attributes.includes("*")) {
+            return 0;
+        }
+        return -1;
+    }
+    /**
+     * Get a binary
+     *
+     * @param {Object} info The reference stored in your target object
+     * @emits 'binaryGet'
+     * @returns the result
+     */
+    async get(info) {
+        await this.emit("Binary.Get", {
+            object: info,
+            service: this
+        });
+        this.metrics.download.inc();
+        return this._get(info);
+    }
+    /**
+     * Download a binary to a file
+     *
+     * @param {Object} info The reference stored in your target object
+     * @param {String} filepath to save the binary to
+     * @param filename - the filename
+     */
+    async downloadTo(info, filename) {
+        await this.emit("Binary.Get", {
+            object: info,
+            service: this
+        });
+        this.metrics.download.inc();
+        const readStream = await this._get(info);
+        const writeStream = fs.createWriteStream(filename);
+        return new Promise((resolve, reject) => {
+            writeStream.on("finish", () => {
+                return resolve();
+            });
+            writeStream.on("error", src => {
+                try {
+                    fs.unlinkSync(filename);
+                    // Stubing the fs module in ESM seems complicated for now
+                    /* c8 ignore next 3 */
+                }
+                catch (err) {
+                    this.log("ERROR", err);
+                }
+                return reject(src);
+            });
+            readStream.pipe(writeStream);
+        });
+    }
+    /**
+     * Based on the raw Map init a BinaryMap
+     * @param obj - the target object
+     * @returns the result map
+     */
+    newModel(obj) {
+        return new BinaryMap(this, obj);
+    }
+    /**
+     * Read a stream to a buffer
+     *
+     * @param stream - the stream
+     * @returns the result
+     */
+    static streamToBuffer(stream) {
+        // codesnippet from https://stackoverflow.com/questions/14269233/node-js-how-to-read-a-stream-into-a-buffer
+        return streamToBuffer(stream);
+    }
+    /**
+     * Check if a map is defined
+     *
+     * @param name - the name to use
+     * @param property - the property name
+     * @param object - the target object
+     */
+    checkMap(object, property) {
+        const { Identifier } = useModelMetadata(object);
+        if (this.handleBinary(Identifier, property) !== -1) {
+            return;
+        }
+        throw new Error("Unknown mapping");
+    }
+    /**
+     * Ensure events are sent correctly after an upload and update the BinaryFileInfo in targetted object
+     * @param object - the target object
+     * @param property - the property name
+     * @param fileInfo - the file information
+     */
+    async uploadSuccess(object, property, fileInfo) {
+        let file;
+        // Ensure we do not have a full object
+        if (fileInfo["toBinaryFileInfo"] && typeof fileInfo["toBinaryFileInfo"] === "function") {
+            file = fileInfo["toBinaryFileInfo"]();
+        }
+        else {
+            file = fileInfo;
+        }
+        // `.filter()` always returns an array, and an empty array is truthy —
+        // the previous `if ((additionalAttr = filter(...)))` form fired on every
+        // upload (legitimate or not), throwing with an empty `properties: `
+        // suffix because `[].join(",")` is `""`. Compare length instead.
+        const additionalAttr = Object.keys(file).filter(k => !["name", "size", "mimetype", "hash", "challenge", "metadata"].includes(k));
+        if (additionalAttr.length > 0) {
+            throw new Error("Invalid file object it should be a plain BinaryFileInfo found additional properties: " +
+                additionalAttr.join(","));
+        }
+        // Persist the BinaryFileInfo on the parent model. After the
+        // Binary→Behavior migration the cardinality lives on
+        // `Metadata.Relations.behaviors[]` (no more `Relations.binaries[]`).
+        // `Webda/BinariesImpl` ⇒ MANY (append), anything else (`Webda/Binary`)
+        // ⇒ ONE (replace).
+        const behaviorRels = object?.constructor?.Metadata?.Relations?.behaviors;
+        const beh = Array.isArray(behaviorRels)
+            ? behaviorRels.find(b => b.attribute === property)
+            : undefined;
+        const isCollection = beh?.behavior === "Webda/BinariesImpl";
+        if (isCollection) {
+            const current = Array.isArray(object[property])
+                ? [...object[property]]
+                : [];
+            // Idempotent push — already-linked check (preserves the previous
+            // behaviour of the now-deleted early-return guard above).
+            if (!current.some(i => i.hash === file.hash)) {
+                current.push(file);
+            }
+            await object.patch({ [property]: current });
+        }
+        else {
+            await object.patch({ [property]: file });
+        }
+        this.metrics.upload.inc();
+    }
+    /**
+     *
+     * @param targetStore - the target store
+     * @param object - the target object
+     * @param property - the property name
+     * @param index - the index
+     * @returns the result
+     */
+    async deleteSuccess(object, property, index) {
+        // Cardinality lives on `Metadata.Relations.behaviors[]` after the
+        // Binary→Behavior migration. `Webda/BinariesImpl` ⇒ MANY (splice),
+        // anything else (`Webda/Binary`) ⇒ ONE (clear). Mirrors the lookup in
+        // `uploadSuccess`.
+        const behaviorRels = object?.constructor?.Metadata?.Relations?.behaviors;
+        const beh = Array.isArray(behaviorRels)
+            ? behaviorRels.find(b => b.attribute === property)
+            : undefined;
+        const isCollection = beh?.behavior === "Webda/BinariesImpl";
+        const info = (isCollection && index !== undefined ? object[property][index] : object[property]);
+        if (isCollection) {
+            const current = Array.isArray(object[property])
+                ? [...object[property]]
+                : [];
+            if (index !== undefined && index >= 0 && index < current.length) {
+                current.splice(index, 1);
+            }
+            await object.patch({ [property]: current });
+        }
+        else {
+            await object.patch({ [property]: undefined });
+        }
+        await this.emit("Binary.Delete", {
+            object: info,
+            service: this
+        });
+        this.metrics.delete.inc();
+    }
+    /**
+     * Get file either from multipart post or raw
+     * @param req - the request
+     * @returns the result
+     */
+    async getFile(req) {
+        const { size } = req.getParameters();
+        let { mimetype, name } = req.getParameters();
+        if (size > this.parameters.maxFileSize) {
+            throw new WebdaError.BadRequest("File too big");
+        }
+        const file = await req.getRawInput(size ?? this.parameters.maxFileSize);
+        mimetype ??= "application/octet-stream";
+        name ??= "data.bin";
+        return new MemoryBinaryFile(Buffer.from(file), {
+            mimetype,
+            size,
+            name: name,
+            hash: crypto.createHash("md5").update(file).digest("hex"),
+            challenge: crypto
+                .createHash("md5")
+                .update("WEBDA" + file)
+                .digest("hex")
+        });
+    }
+    /**
+     * Return the name of the service for OpenAPI
+     * @returns the result string
+     */
+    getOperationName() {
+        return this.name.toLowerCase() === "binary" ? "" : this.name;
+    }
+    /**
+     * Based on the request parameter verify it match a known mapping
+     * @param ctx - the operation context
+     * @returns the result
+     */
+    verifyMapAndStore(ctx) {
+        // Check for model
+        if (this.handleBinary(ctx.parameter("model"), ctx.parameter("property")) === -1) {
+            throw new WebdaError.NotFound("Model not managed by this store");
+        }
+        // TODO: Refactor
+        return null; //<IStore>useCore().getModelStore(useModel(ctx.parameter("model")));
+    }
+    /**
+     * By default no challenge is managed so throws 404
+     *
+     * @param args - additional arguments
+     */
+    async putRedirectUrl(...args) {
+        // Dont handle the redirect url
+        throw new WebdaError.NotFound("No redirect url");
+    }
+}
+//# sourceMappingURL=binary.service.js.map