@visulima/storage 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/packem_shared/sharedGet-DAyJfjhl.js

@@ -0,0 +1,1018 @@
+const FileMetaExample = {
+  value: {
+    createdAt: "2022-12-16T10:35:17.466Z",
+    id: "391c9157ec481ac6-f72b2d884632d7e6-cdeb2056546033e3",
+    modifiedAt: "2022-12-16T10:35:17.470Z"
+  }
+};
+const createParameterGroup = (parameters, groupName) => parameters.map((parameter) => {
+  return {
+    ...parameter,
+    description: `[${groupName}] ${parameter.description}`,
+    // Add extension for better tooling support
+    "x-group": groupName
+  };
+});
+const getTransformationParameters = (transform, format = ["jpeg", "png", "webp", "avif", "tiff", "gif", "mp4", "webm", "mkv", "ogg", "mp3", "wav", "aac", "flac"]) => {
+  if (!transform) {
+    return [];
+  }
+  const commonParameters = createParameterGroup(
+    [
+      {
+        description: "Output format for the transformed media",
+        in: "query",
+        name: "format",
+        schema: {
+          enum: format,
+          type: "string"
+        }
+      },
+      {
+        description: "Quality setting (0-100 for images, affects compression)",
+        in: "query",
+        name: "quality",
+        schema: {
+          maximum: 100,
+          minimum: 1,
+          type: "integer"
+        }
+      }
+    ],
+    "Common"
+  );
+  const imageParameters = createParameterGroup(
+    [
+      {
+        description: "Desired width in pixels",
+        in: "query",
+        name: "width",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Desired height in pixels",
+        in: "query",
+        name: "height",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Resize fit mode",
+        in: "query",
+        name: "fit",
+        schema: {
+          enum: ["cover", "contain", "fill", "inside", "outside"],
+          type: "string"
+        }
+      },
+      {
+        description: "Position for cover/contain fits",
+        in: "query",
+        name: "position",
+        schema: {
+          oneOf: [
+            {
+              enum: ["top", "right", "bottom", "left", "center"],
+              type: "string"
+            },
+            {
+              minimum: 0,
+              type: "integer"
+            }
+          ]
+        }
+      },
+      {
+        description: "Avoid enlarging images smaller than specified dimensions",
+        in: "query",
+        name: "withoutEnlargement",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Avoid reducing images larger than specified dimensions",
+        in: "query",
+        name: "withoutReduction",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Resize kernel algorithm",
+        in: "query",
+        name: "kernel",
+        schema: {
+          enum: ["nearest", "cubic", "mitchell", "lanczos2", "lanczos3"],
+          type: "string"
+        }
+      },
+      {
+        description: "Fast shrink on load for large images",
+        in: "query",
+        name: "fastShrinkOnLoad",
+        schema: {
+          type: "boolean"
+        }
+      },
+      // Crop parameters
+      {
+        description: "Crop area left offset",
+        in: "query",
+        name: "left",
+        schema: {
+          minimum: 0,
+          type: "integer"
+        }
+      },
+      {
+        description: "Crop area top offset",
+        in: "query",
+        name: "top",
+        schema: {
+          minimum: 0,
+          type: "integer"
+        }
+      },
+      {
+        description: "Crop area width",
+        in: "query",
+        name: "cropWidth",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Crop area height",
+        in: "query",
+        name: "cropHeight",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Rotation angle in degrees. Note: angles other than 90°, 180°, and 270° require interpolation and may affect quality",
+        in: "query",
+        name: "angle",
+        schema: {
+          type: "number"
+        }
+      },
+      {
+        description: "Background color for rotation (hex, rgb, or color name)",
+        in: "query",
+        name: "background",
+        schema: {
+          type: "string"
+        }
+      },
+      // Image operations
+      {
+        description: "Apply blur effect",
+        in: "query",
+        name: "blur",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Apply sharpening",
+        in: "query",
+        name: "sharpen",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Apply median filter with specified size",
+        in: "query",
+        name: "median",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)",
+        in: "query",
+        name: "clahe",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Apply thresholding with specified value (0-255)",
+        in: "query",
+        name: "threshold",
+        schema: {
+          maximum: 255,
+          minimum: 0,
+          type: "integer"
+        }
+      },
+      {
+        description: "Apply gamma correction",
+        in: "query",
+        name: "gamma",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Negate (invert) the image",
+        in: "query",
+        name: "negate",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Normalise the image",
+        in: "query",
+        name: "normalise",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Flatten alpha channel",
+        in: "query",
+        name: "flatten",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Unflatten alpha channel",
+        in: "query",
+        name: "unflatten",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Flip image vertically",
+        in: "query",
+        name: "flip",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Flop image horizontally",
+        in: "query",
+        name: "flop",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Convert to greyscale",
+        in: "query",
+        name: "greyscale",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Apply modulation effects",
+        in: "query",
+        name: "modulate",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Brightness multiplier for modulation",
+        in: "query",
+        name: "brightness",
+        schema: {
+          type: "number"
+        }
+      },
+      {
+        description: "Saturation multiplier for modulation",
+        in: "query",
+        name: "saturation",
+        schema: {
+          type: "number"
+        }
+      },
+      {
+        description: "Hue rotation in degrees for modulation",
+        in: "query",
+        name: "hue",
+        schema: {
+          type: "integer"
+        }
+      },
+      {
+        description: "Lightness adjustment for modulation",
+        in: "query",
+        name: "lightness",
+        schema: {
+          type: "integer"
+        }
+      },
+      {
+        description: "Apply tinting",
+        in: "query",
+        name: "tint",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Convert colourspace",
+        in: "query",
+        name: "colourspace",
+        schema: {
+          enum: ["srgb", "rgb", "cmyk", "lab", "b-w"],
+          type: "string"
+        }
+      },
+      {
+        description: "Apply affine transformation",
+        in: "query",
+        name: "affine",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Apply dilation",
+        in: "query",
+        name: "dilate",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Apply erosion",
+        in: "query",
+        name: "erode",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Set pipeline colourspace",
+        in: "query",
+        name: "pipelineColourspace",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Convert to colourspace",
+        in: "query",
+        name: "toColourspace",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Remove alpha channel",
+        in: "query",
+        name: "removeAlpha",
+        schema: {
+          type: "boolean"
+        }
+      },
+      {
+        description: "Ensure alpha channel",
+        in: "query",
+        name: "ensureAlpha",
+        schema: {
+          type: "boolean"
+        }
+      }
+    ],
+    "Image"
+  );
+  const videoParameters = createParameterGroup(
+    [
+      {
+        description: "Desired width in pixels",
+        in: "query",
+        name: "width",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Desired height in pixels",
+        in: "query",
+        name: "height",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Video frame rate in Hz",
+        in: "query",
+        name: "frameRate",
+        schema: {
+          minimum: 1,
+          type: "number"
+        }
+      },
+      {
+        description: "Video key frame interval in seconds",
+        in: "query",
+        name: "keyFrameInterval",
+        schema: {
+          minimum: 0.1,
+          type: "number"
+        }
+      }
+    ],
+    "Video"
+  );
+  const videoAudioParameters = createParameterGroup(
+    [
+      {
+        description: "Target bitrate in bits per second",
+        in: "query",
+        name: "bitrate",
+        schema: {
+          minimum: 1,
+          type: "integer"
+        }
+      },
+      {
+        description: "Video or audio codec",
+        in: "query",
+        name: "codec",
+        schema: {
+          enum: ["avc", "hevc", "vp8", "vp9", "av1", "aac", "opus", "mp3", "vorbis", "flac"],
+          type: "string"
+        }
+      }
+    ],
+    "Video/Audio"
+  );
+  const audioParameters = createParameterGroup(
+    [
+      {
+        description: "Audio channel count",
+        in: "query",
+        name: "numberOfChannels",
+        schema: {
+          enum: [1, 2, 3, 4, 5, 6, 7, 8],
+          type: "integer"
+        }
+      },
+      {
+        description: "Audio sample rate in Hz",
+        in: "query",
+        name: "sampleRate",
+        schema: {
+          enum: [8e3, 11025, 16e3, 22050, 32e3, 44100, 48e3, 88200, 96e3, 192e3],
+          type: "integer"
+        }
+      }
+    ],
+    "Audio"
+  );
+  let parameters = [];
+  parameters = [...parameters, ...commonParameters];
+  if (transform === true || transform === "image") {
+    parameters = [...parameters, ...imageParameters];
+  }
+  if (transform === true || transform === "video") {
+    parameters = [...parameters, ...videoParameters];
+  }
+  if (transform === true || transform === "video" || transform === "audio") {
+    parameters = [...parameters, ...videoAudioParameters];
+  }
+  if (transform === true || transform === "audio") {
+    parameters = [...parameters, ...audioParameters];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return parameters.filter((parameter) => {
+    if (seen.has(parameter.name)) {
+      return false;
+    }
+    seen.add(parameter.name);
+    return true;
+  });
+};
+const getOrganizedTransformationParameters = (transform, format = ["jpeg", "png", "webp", "avif", "tiff", "gif", "mp4", "webm", "mkv", "ogg", "mp3", "wav", "aac", "flac"]) => {
+  const parameters = getTransformationParameters(transform, format);
+  const groups = {};
+  parameters.forEach((parameter) => {
+    const group = parameter["x-group"] || "Other";
+    if (!groups[group]) {
+      groups[group] = [];
+    }
+    groups[group].push(parameter.name);
+  });
+  return { groups, parameters };
+};
+const getTransformationHeaders = (transform) => {
+  if (!transform) return {};
+  const headers = {
+    "X-Media-Type": {
+      description: "Type of media (image/video/audio)",
+      schema: {
+        enum: ["image", "video", "audio"],
+        type: "string"
+      }
+    },
+    "X-Original-Format": {
+      description: "Original file format",
+      schema: {
+        type: "string"
+      }
+    },
+    "X-Transformed-Format": {
+      description: "Transformed file format",
+      schema: {
+        type: "string"
+      }
+    }
+  };
+  return headers;
+};
+const getTransformationErrorResponses = (transform) => {
+  if (!transform) return {};
+  return {
+    400: {
+      content: {
+        "application/json": {
+          examples: {
+            ValidationError: {
+              value: {
+                error: {
+                  code: "INVALID_PARAMS_FOR_IMAGE",
+                  details: {
+                    invalidParams: ["codec", "bitrate"],
+                    mediaType: "image",
+                    validParams: [
+                      "format",
+                      "quality",
+                      "width",
+                      "height",
+                      "fit",
+                      "position",
+                      "withoutEnlargement",
+                      "withoutReduction",
+                      "kernel",
+                      "fastShrinkOnLoad",
+                      "left",
+                      "top",
+                      "cropWidth",
+                      "cropHeight",
+                      "angle",
+                      "background",
+                      "blur",
+                      "sharpen",
+                      "median",
+                      "clahe",
+                      "threshold",
+                      "gamma",
+                      "negate",
+                      "normalise",
+                      "flatten",
+                      "unflatten",
+                      "flip",
+                      "flop",
+                      "greyscale",
+                      "modulate",
+                      "brightness",
+                      "saturation",
+                      "hue",
+                      "lightness",
+                      "tint",
+                      "colourspace",
+                      "affine",
+                      "dilate",
+                      "erode",
+                      "pipelineColourspace",
+                      "toColourspace",
+                      "removeAlpha",
+                      "ensureAlpha"
+                    ]
+                  },
+                  message: "Invalid query parameters for image transformation: codec, bitrate. Images support: format, quality, width, height, fit, position, withoutEnlargement, withoutReduction, kernel, fastShrinkOnLoad, left, top, cropWidth, cropHeight, angle, background, blur, sharpen, median, clahe, threshold, gamma, negate, normalise, flatten, unflatten, flip, flop, greyscale, modulate, brightness, saturation, hue, lightness, tint, colourspace, affine, dilate, erode, pipelineColourspace, toColourspace, removeAlpha, ensureAlpha. Video/audio parameters (codec, bitrate) are not supported for images.",
+                  name: "ValidationError"
+                }
+              }
+            }
+          },
+          schema: {
+            $ref: "#/components/schemas/ValidationError"
+          }
+        }
+      },
+      description: "Invalid transformation parameters"
+    },
+    413: {
+      content: {
+        "application/json": {
+          schema: {
+            $ref: "#/components/schemas/Error"
+          }
+        }
+      },
+      description: "File too large for transformation"
+    },
+    415: {
+      content: {
+        "application/json": {
+          schema: {
+            $ref: "#/components/schemas/Error"
+          }
+        }
+      },
+      description: "Unsupported media type for transformation"
+    }
+  };
+};
+const sharedGet = (operationId, tags, transform, transformerFormat) => {
+  return {
+    description: "Get the uploaded file with optional media transformation support",
+    operationId,
+    parameters: [
+      {
+        in: "path",
+        name: "id",
+        required: true,
+        schema: {
+          type: "string"
+        }
+      },
+      ...getTransformationParameters(transform, transformerFormat)
+    ],
+    responses: {
+      200: {
+        content: {
+          "*/*": {
+            schema: {
+              description: transform ? "Transformed file content" : "File content",
+              format: "binary",
+              type: "string"
+            }
+          }
+        },
+        description: transform ? "File retrieved and transformed successfully" : "File retrieved successfully",
+        headers: {
+          "Content-Type": {
+            description: `MIME type of the file${transform ? " (or transformed file)" : ""}`,
+            schema: {
+              type: "string"
+            }
+          },
+          ETag: {
+            description: `Upload ETag${transform ? " (or transformed file ETag)" : ""}`,
+            schema: {
+              example: "d41d8cd98f00b204e9800998ecf8427e",
+              type: "string"
+            }
+          },
+          "Last-Modified": {
+            description: "Upload last modified date",
+            schema: {
+              example: "2021-08-25T11:12:26.635Z",
+              format: "date-time",
+              type: "string"
+            }
+          },
+          ...getTransformationHeaders(transform),
+          "X-Upload-Expires": {
+            description: "Upload expiration date",
+            schema: {
+              example: "2021-08-25T11:12:26.635Z",
+              format: "date-time",
+              type: "string"
+            }
+          }
+        }
+      },
+      ...getTransformationErrorResponses(transform),
+      404: {
+        content: {
+          "application/json": {
+            example: {
+              error: {
+                code: "FileNotFound",
+                message: "Not found"
+              }
+            },
+            schema: {
+              $ref: "#/components/schemas/Error"
+            }
+          }
+        },
+        description: "Not Found"
+      },
+      default: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/Error"
+            }
+          }
+        },
+        description: "Error"
+      }
+    },
+    summary: "Get the uploaded file",
+    tags
+  };
+};
+const sharedGetMeta = (operationId, tags) => {
+  return {
+    description: "Get the uploaded file metadata",
+    operationId,
+    parameters: [
+      {
+        in: "path",
+        name: "id",
+        required: true,
+        schema: {
+          type: "string"
+        }
+      }
+    ],
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/FileMeta"
+            }
+          }
+        },
+        description: "OK",
+        headers: {
+          "Last-Modified": {
+            description: "Upload last modified date",
+            schema: {
+              example: "2021-08-25T11:12:26.635Z",
+              format: "date-time",
+              type: "string"
+            }
+          },
+          "X-Upload-Expires": {
+            description: "Upload expiration date",
+            schema: {
+              example: "2021-08-25T11:12:26.635Z",
+              format: "date-time",
+              type: "string"
+            }
+          }
+        }
+      },
+      404: {
+        content: {
+          "application/json": {
+            example: {
+              error: {
+                code: "FileNotFound",
+                message: "File metadata not found"
+              }
+            },
+            schema: {
+              $ref: "#/components/schemas/Error"
+            }
+          }
+        },
+        description: "Not Found"
+      },
+      default: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/Error"
+            }
+          }
+        },
+        description: "Error"
+      }
+    },
+    summary: "Get the uploaded file metadata",
+    tags
+  };
+};
+const sharedErrorSchemaObject = {
+  Error: {
+    description: "Error",
+    properties: {
+      error: {
+        properties: {
+          code: {
+            minLength: 1,
+            type: "string"
+          },
+          message: {
+            minLength: 1,
+            type: "string"
+          },
+          name: {
+            minLength: 3,
+            type: "string"
+          }
+        },
+        required: ["message"],
+        type: "object"
+      }
+    },
+    required: ["error"],
+    type: "object"
+  },
+  // Validation error schema
+  ValidationError: {
+    description: "Validation error response",
+    properties: {
+      code: {
+        enum: [
+          "INVALID_PARAMS_FOR_IMAGE",
+          "INVALID_PARAMS_FOR_VIDEO",
+          "INVALID_PARAMS_FOR_AUDIO",
+          "INVALID_FIT_VALUE",
+          "INVALID_ANGLE_VALUE",
+          "INVALID_FORMAT",
+          "INCOMPLETE_CROP_PARAMS",
+          "INVALID_VIDEO_CODEC",
+          "INVALID_VIDEO_FORMAT",
+          "INVALID_WIDTH",
+          "INVALID_HEIGHT",
+          "INVALID_BITRATE",
+          "INVALID_FRAME_RATE",
+          "INVALID_KEY_FRAME_INTERVAL",
+          "INVALID_AUDIO_CODEC",
+          "INVALID_AUDIO_FORMAT",
+          "INVALID_CHANNEL_COUNT",
+          "INVALID_SAMPLE_RATE"
+        ],
+        type: "string"
+      },
+      details: {
+        properties: {
+          invalidParams: {
+            items: {
+              type: "string"
+            },
+            type: "array"
+          },
+          mediaType: {
+            enum: ["image", "video", "audio"],
+            type: "string"
+          },
+          suggestions: {
+            items: {
+              type: "string"
+            },
+            type: "array"
+          },
+          validParams: {
+            items: {
+              type: "string"
+            },
+            type: "array"
+          }
+        },
+        required: ["invalidParams", "validParams", "mediaType"],
+        type: "object"
+      },
+      message: {
+        type: "string"
+      },
+      name: {
+        enum: ["ValidationError"],
+        type: "string"
+      }
+    },
+    required: ["code", "details", "message", "name"],
+    type: "object"
+  }
+};
+const sharedFileMetaSchemaObject = {
+  FileMeta: {
+    description: "File meta",
+    properties: {
+      bytesWritten: {
+        type: "integer"
+      },
+      contentType: {
+        type: "string"
+      },
+      createdAt: {
+        format: "date-time",
+        type: "string"
+      },
+      id: {
+        minLength: 1,
+        type: "string"
+      },
+      metadata: {
+        type: "object"
+      },
+      name: {
+        minLength: 1,
+        type: "string"
+      },
+      originalName: {
+        minLength: 1,
+        type: "string"
+      },
+      status: {
+        enum: ["completed", "part", "deleted", "created"],
+        type: "string"
+      }
+    },
+    type: "object"
+  }
+};
+const sharedFileMetaExampleObject = {
+  FileMeta: {
+    value: [FileMetaExample]
+  },
+  FileMetaPagination: {
+    value: {
+      data: [FileMetaExample.value],
+      meta: {
+        firstPage: 1,
+        firstPageUrl: "/?page=1",
+        lastPage: 1,
+        lastPageUrl: "/?page=10",
+        nextPageUrl: "/?page=2",
+        page: 1,
+        perPage: 1,
+        previousPageUrl: void 0,
+        total: 1
+      }
+    }
+  }
+};
+const sharedGetList = (operationId, tags) => {
+  return {
+    description: "List upload",
+    operationId,
+    parameters: [
+      {
+        description: "Maximum number of elements to retrieve.",
+        in: "query",
+        name: "limit",
+        schema: {
+          nullable: true,
+          type: "integer"
+        }
+      },
+      {
+        description: "Page number. Use only for pagination.",
+        in: "query",
+        name: "page",
+        schema: {
+          nullable: true,
+          type: "integer"
+        }
+      }
+    ],
+    responses: {
+      200: {
+        content: {
+          "application/json": {
+            examples: {
+              Default: {
+                $ref: "#/components/examples/FileMeta"
+              },
+              Pagination: {
+                $ref: "#/components/examples/FileMetaPagination"
+              }
+            },
+            schema: {
+              $ref: "#/components/schemas/FileMeta"
+            }
+          }
+        },
+        description: "OK"
+      },
+      default: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: "#/components/schemas/Error"
+            }
+          }
+        },
+        description: "Error"
+      }
+    },
+    summary: "List upload",
+    tags
+  };
+};
+
+export { getOrganizedTransformationParameters, sharedErrorSchemaObject, sharedFileMetaExampleObject, sharedFileMetaSchemaObject, sharedGet, sharedGetList, sharedGetMeta };