@tulip-systems/core 0.7.0 → 0.8.1

package/dist/modules/storage/lib/validators.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.mts","names":[],"sources":["../../../../src/modules/storage/lib/validators.ts"],"mappings":"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"}
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../../../../src/modules/storage/lib/validators.ts"],"mappings":";;;;;;;;;;KASY,YAAA,UAAsB,aAAA,CAAc,YAAA;;AAAhD;;cAKa,4BAAA,EAA4B,GAAA,CAAA,OAAA;;;;KAC7B,sBAAA,GAAyB,GAAA,CAAE,KAAA,QAAa,4BAAA;;;;cAKvC,wBAAA,eAAwB,WAAA;YAAoC,oBAAA,CAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAE7D,uBAAA,GAA0B,GAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,KACzC,wBAAA,GAA2B,GAAA,CAAE,KAAA,QAAa,wBAAA;;;;cAKzC,wBAAA,eAAwB,WAAA;YAAoC,oBAAA,CAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAE7D,uBAAA,GAA0B,GAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,KACzC,wBAAA,GAA2B,GAAA,CAAE,KAAA,QAAa,wBAAA;;;;cAKzC,wBAAA,eAAwB,WAAA;YAAoC,oBAAA,CAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAE7D,wBAAA,GAA2B,GAAA,CAAE,KAAA,QAAa,wBAAA;;;;cAOzC,iBAAA,EAAiB,GAAA,CAAA,SAAA;;;;;;;;;;;cASjB,wBAAA,EAAwB,GAAA,CAAA,SAAA;;;;;;;;;;;cASxB,yBAAA,EAAyB,GAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAIzB,wBAAA,EAAwB,GAAA,CAAA,OAAA;AAAA,KAIzB,WAAA,GAAc,GAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAC7B,kBAAA,GAAqB,GAAA,CAAE,KAAA,QAAa,wBAAA;AAAA,KACpC,mBAAA,GAAsB,GAAA,CAAE,KAAA,QAAa,yBAAA;AAAA,KACrC,kBAAA,GAAqB,GAAA,CAAE,KAAA,QAAa,wBAAA;;;;cAKnC,iBAAA,EAAiB,GAAA,CAAA,SAAA;;;;;;KAIlB,gBAAA,GAAmB,GAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAClC,iBAAA,GAAoB,GAAA,CAAE,KAAA,QAAa,iBAAA"}

package/dist/modules/storage/lib/validators.mjs

@@ -1,97 +1,53 @@
-import { resolveFiltersSchema } from "../../data-tables/lib/filters/resolvers.mjs";
-import { tableQuerySchema } from "../../data-tables/lib/validators.mjs";
-import { imageDispositions, imageVariants } from "./constants.mjs";
-import { nodeModeEnum, nodes } from "./schema.mjs";
-import { nodesTableFilters } from "../config/filters.mjs";
+import { imageDispositions } from "./constants.mjs";
+import { storageAssetVisibilityEnum, storageAssets } from "./schema.mjs";
+import { getObjectOptionsDefaults, objectBodyInputSchema } from "../providers/lib/validators.mjs";
 import { createInsertSchema, createSelectSchema, createUpdateSchema } from "drizzle-zod";
 import { z as z$1 } from "zod";
 
 //#region src/modules/storage/lib/validators.ts
 /**
-* Node mode
+* StorageAsset visibility enum
 */
-const nodeModeSchema = z$1.enum(nodeModeEnum.enumValues);
+const storageAssetVisibilitySchema = z$1.enum(storageAssetVisibilityEnum.enumValues);
 /**
-* Create node
+* Create storageAsset
 */
-const createNodeSchema = createInsertSchema(nodes, { namespace: z$1.string() });
+const createStorageAssetSchema = createInsertSchema(storageAssets);
 /**
-* Update node
+* Update storageAsset
 */
-const updateNodeSchema = createUpdateSchema(nodes);
+const updateStorageAssetSchema = createUpdateSchema(storageAssets);
 /**
-* Select node
+* Select storageAsset
 */
-const selectNodeSchema = createSelectSchema(nodes);
-const selectNodeWithChildrenSchema = selectNodeSchema.extend({ children: z$1.array(selectNodeSchema) });
+const selectStorageAssetSchema = createSelectSchema(storageAssets);
+const assetMetadataSchema = z$1.record(z$1.string(), z$1.string()).optional();
 /**
-* Where input
+* Upload schema
 */
-const nodesTableFiltersSchema = resolveFiltersSchema(nodesTableFilters).partial().extend({
-	namespace: z$1.string(),
-	parentId: z$1.string().nullable()
-}).transform((input) => ({
-	...input,
-	hidden: input?.hidden ?? false,
-	isDeleted: input?.isDeleted ?? false,
-	orphanedAt: input?.isOrphaned ?? false
-}));
-/**
-* Create folder node
-*/
-const createFolderNodeSchema = createNodeSchema.omit({
-	type: true,
-	contentType: true,
-	size: true,
-	subtype: true
-});
-/**
-* Upload file schema
-*/
-const uploadFileSchema = createNodeSchema.omit({ type: true });
-/**
-* Presign file schema
-*/
-const presignFileSchema = uploadFileSchema.extend({ id: z$1.uuid() });
-/**
-* Get file url schema
-*/
-const getFileURLSchemaDefaults = {
-	variant: "main",
-	disposition: "inline"
-};
-const getFileURLSchema = z$1.object({
-	variant: z$1.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),
-	disposition: z$1.enum(imageDispositions).optional().default(getFileURLSchemaDefaults.disposition)
+const uploadInputSchema = z$1.object({
+	name: z$1.string().min(1),
+	visibility: storageAssetVisibilitySchema.optional().default("private"),
+	size: z$1.number().int().nonnegative().nullable().optional(),
+	contentType: z$1.string().nullable().optional(),
+	metadata: assetMetadataSchema,
+	body: objectBodyInputSchema
 });
-/**
-* Get by parent id input
-*/
-const getNodesByParentIdSchema = tableQuerySchema.pick({
-	order: true,
-	sort: true,
-	search: true
-}).extend({ filters: nodesTableFiltersSchema });
-/**
-* Get object input
-*/
-const getObjectSchema = z$1.object({
-	id: z$1.string(),
-	variant: z$1.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),
-	disposition: z$1.string().optional().default(getFileURLSchemaDefaults.disposition)
+const presignUploadInputSchema = z$1.object({
+	uploadId: z$1.uuid().optional(),
+	name: z$1.string().min(1),
+	visibility: storageAssetVisibilitySchema.optional().default("private"),
+	size: z$1.number().int().nonnegative().nullable().optional(),
+	contentType: z$1.string().nullable().optional(),
+	metadata: assetMetadataSchema
 });
+const presignUploadOutputSchema = selectStorageAssetSchema.extend({ presignedUrl: z$1.string() });
+const confirmUploadInputSchema = z$1.uuid().describe("The upload id of the pending upload to confirm, returned from the presign endpoint");
 /**
-* Put object input
+* Get file url schema
 */
-const putObjectSchema = z$1.object({
-	id: z$1.string(),
-	name: z$1.string().optional().default(""),
-	variant: z$1.enum(imageVariants).optional().default("main"),
-	body: z$1.any().optional(),
-	contentType: z$1.string().nullable().optional(),
-	size: z$1.number().nullable().optional()
-});
+const getAssetURLSchema = z$1.object({ disposition: z$1.enum(imageDispositions).optional().default(getObjectOptionsDefaults.disposition) });
 
 //#endregion
-export { createFolderNodeSchema, createNodeSchema, getFileURLSchema, getFileURLSchemaDefaults, getNodesByParentIdSchema, getObjectSchema, nodeModeSchema, nodesTableFiltersSchema, presignFileSchema, putObjectSchema, selectNodeSchema, selectNodeWithChildrenSchema, updateNodeSchema, uploadFileSchema };
+export { confirmUploadInputSchema, createStorageAssetSchema, getAssetURLSchema, presignUploadInputSchema, presignUploadOutputSchema, selectStorageAssetSchema, storageAssetVisibilitySchema, updateStorageAssetSchema, uploadInputSchema };
 //# sourceMappingURL=validators.mjs.map

package/dist/modules/storage/lib/validators.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"validators.mjs","names":["z"],"sources":["../../../../src/modules/storage/lib/validators.ts"],"sourcesContent":["import type { PutObjectCommandInput } from \"@aws-sdk/client-s3\";\nimport { createInsertSchema, createSelectSchema, createUpdateSchema } from \"drizzle-zod\";\nimport { z } from \"zod\";\nimport { tableQuerySchema } from \"@/modules/data-tables/entry\";\nimport { resolveFiltersSchema } from \"@/modules/data-tables/lib/filters/resolvers\";\nimport { nodesTableFilters } from \"../config/filters\";\nimport { imageDispositions, imageVariants } from \"./constants\";\nimport { nodeModeEnum, nodes } from \"./schema\";\n\n/**\n * Nodes\n */\nexport type Node = typeof nodes.$inferSelect;\nexport type FileNode = typeof nodes.$inferSelect & { type: \"file\" };\nexport type FolderNode = typeof nodes.$inferSelect & { type: \"folder\" };\n\n/**\n * Node mode\n */\nexport const nodeModeSchema = z.enum(nodeModeEnum.enumValues);\nexport type NodeMode = z.infer<typeof nodeModeSchema>;\n\n/**\n * Create node\n */\nexport const createNodeSchema = createInsertSchema(nodes, {\n  namespace: z.string(),\n});\n\nexport type CreateNodeInput = z.input<typeof createNodeSchema>;\nexport type CreateNodeSchema = z.infer<typeof createNodeSchema>;\n\n/**\n * Update node\n */\nexport const updateNodeSchema = createUpdateSchema(nodes);\n\nexport type UpdateNodeInput = z.input<typeof updateNodeSchema>;\nexport type UpdateNodeSchema = z.infer<typeof updateNodeSchema>;\n\n/**\n * Select node\n */\nexport const selectNodeSchema = createSelectSchema(nodes);\nexport const selectNodeWithChildrenSchema = selectNodeSchema.extend({\n  children: z.array(selectNodeSchema),\n});\n\nexport type SelectNodeSchema = z.infer<typeof selectNodeSchema>;\nexport type SelectNodeWithChildrenSchema = z.infer<typeof selectNodeWithChildrenSchema>;\n\n/**\n * Where input\n */\nexport const nodesTableFiltersSchema = resolveFiltersSchema(nodesTableFilters)\n  .partial()\n  .extend({\n    namespace: z.string(),\n    parentId: z.string().nullable(),\n  })\n  .transform((input) => ({\n    ...input,\n    hidden: input?.hidden ?? false,\n    isDeleted: input?.isDeleted ?? false,\n    orphanedAt: input?.isOrphaned ?? false,\n  }));\n\nexport type NodesTableFilters = z.input<typeof nodesTableFiltersSchema>;\n\n/**\n * Create folder node\n */\nexport const createFolderNodeSchema = createNodeSchema.omit({\n  type: true,\n  contentType: true,\n  size: true,\n  subtype: true,\n});\n\nexport type CreateFolderNodeSchema = z.infer<typeof createFolderNodeSchema>;\n\n/**\n * Upload file schema\n */\nexport const uploadFileSchema = createNodeSchema.omit({ type: true });\n\nexport type UploadFileSchema = z.infer<typeof uploadFileSchema>;\n\n/**\n * Presign file schema\n */\nexport const presignFileSchema = uploadFileSchema.extend({ id: z.uuid() });\n\nexport type PresignFileSchema = z.infer<typeof presignFileSchema>;\n\n/**\n * Get file url schema\n */\nexport const getFileURLSchemaDefaults = { variant: \"main\", disposition: \"inline\" } as const;\n\nexport const getFileURLSchema = z.object({\n  variant: z.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),\n  disposition: z.enum(imageDispositions).optional().default(getFileURLSchemaDefaults.disposition),\n});\n\nexport type GetFileUrlInput = z.input<typeof getFileURLSchema>;\nexport type GetFileURLSchema = z.infer<typeof getFileURLSchema>;\n\n/**\n * Get by parent id input\n */\nexport const getNodesByParentIdSchema = tableQuerySchema\n  .pick({ order: true, sort: true, search: true })\n  .extend({ filters: nodesTableFiltersSchema });\n\nexport type GetNodesByParentIdInput = z.input<typeof getNodesByParentIdSchema>;\n\n/**\n * Get object input\n */\nexport const getObjectSchema = z.object({\n  id: z.string(),\n  variant: z.enum(imageVariants).optional().default(getFileURLSchemaDefaults.variant),\n  disposition: z.string().optional().default(getFileURLSchemaDefaults.disposition),\n});\n\nexport type GetObjectInput = z.input<typeof getObjectSchema>;\nexport type GetObjectSchema = z.infer<typeof getObjectSchema>;\n\n/**\n * Put object input\n */\nexport const putObjectSchema = z.object({\n  id: z.string(),\n  name: z.string().optional().default(\"\"),\n  variant: z.enum(imageVariants).optional().default(\"main\"),\n  body: z.any().optional(),\n  contentType: z.string().nullable().optional(),\n  size: z.number().nullable().optional(),\n});\n\nexport type PutObjectInput = z.input<typeof putObjectSchema> & {\n  body?: PutObjectCommandInput[\"Body\"];\n};\n\nexport type PutObjectSchema = z.infer<typeof putObjectSchema>;\n"],"mappings":";;;;;;;;;;;;AAmBA,MAAa,iBAAiBA,IAAE,KAAK,aAAa,WAAW;;;;AAM7D,MAAa,mBAAmB,mBAAmB,OAAO,EACxD,WAAWA,IAAE,QAAQ,EACtB,CAAC;;;;AAQF,MAAa,mBAAmB,mBAAmB,MAAM;;;;AAQzD,MAAa,mBAAmB,mBAAmB,MAAM;AACzD,MAAa,+BAA+B,iBAAiB,OAAO,EAClE,UAAUA,IAAE,MAAM,iBAAiB,EACpC,CAAC;;;;AAQF,MAAa,0BAA0B,qBAAqB,kBAAkB,CAC3E,SAAS,CACT,OAAO;CACN,WAAWA,IAAE,QAAQ;CACrB,UAAUA,IAAE,QAAQ,CAAC,UAAU;CAChC,CAAC,CACD,WAAW,WAAW;CACrB,GAAG;CACH,QAAQ,OAAO,UAAU;CACzB,WAAW,OAAO,aAAa;CAC/B,YAAY,OAAO,cAAc;CAClC,EAAE;;;;AAOL,MAAa,yBAAyB,iBAAiB,KAAK;CAC1D,MAAM;CACN,aAAa;CACb,MAAM;CACN,SAAS;CACV,CAAC;;;;AAOF,MAAa,mBAAmB,iBAAiB,KAAK,EAAE,MAAM,MAAM,CAAC;;;;AAOrE,MAAa,oBAAoB,iBAAiB,OAAO,EAAE,IAAIA,IAAE,MAAM,EAAE,CAAC;;;;AAO1E,MAAa,2BAA2B;CAAE,SAAS;CAAQ,aAAa;CAAU;AAElF,MAAa,mBAAmBA,IAAE,OAAO;CACvC,SAASA,IAAE,KAAK,cAAc,CAAC,UAAU,CAAC,QAAQ,yBAAyB,QAAQ;CACnF,aAAaA,IAAE,KAAK,kBAAkB,CAAC,UAAU,CAAC,QAAQ,yBAAyB,YAAY;CAChG,CAAC;;;;AAQF,MAAa,2BAA2B,iBACrC,KAAK;CAAE,OAAO;CAAM,MAAM;CAAM,QAAQ;CAAM,CAAC,CAC/C,OAAO,EAAE,SAAS,yBAAyB,CAAC;;;;AAO/C,MAAa,kBAAkBA,IAAE,OAAO;CACtC,IAAIA,IAAE,QAAQ;CACd,SAASA,IAAE,KAAK,cAAc,CAAC,UAAU,CAAC,QAAQ,yBAAyB,QAAQ;CACnF,aAAaA,IAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,yBAAyB,YAAY;CACjF,CAAC;;;;AAQF,MAAa,kBAAkBA,IAAE,OAAO;CACtC,IAAIA,IAAE,QAAQ;CACd,MAAMA,IAAE,QAAQ,CAAC,UAAU,CAAC,QAAQ,GAAG;CACvC,SAASA,IAAE,KAAK,cAAc,CAAC,UAAU,CAAC,QAAQ,OAAO;CACzD,MAAMA,IAAE,KAAK,CAAC,UAAU;CACxB,aAAaA,IAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CAC7C,MAAMA,IAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CACvC,CAAC"}
+{"version":3,"file":"validators.mjs","names":["z"],"sources":["../../../../src/modules/storage/lib/validators.ts"],"sourcesContent":["import { createInsertSchema, createSelectSchema, createUpdateSchema } from \"drizzle-zod\";\nimport { z } from \"zod\";\nimport { getObjectOptionsDefaults, objectBodyInputSchema } from \"../providers/lib/validators\";\nimport { imageDispositions } from \"./constants\";\nimport { storageAssets, storageAssetVisibilityEnum } from \"./schema\";\n\n/**\n * StorageAssets\n */\nexport type StorageAsset = typeof storageAssets.$inferSelect;\n\n/**\n * StorageAsset visibility enum\n */\nexport const storageAssetVisibilitySchema = z.enum(storageAssetVisibilityEnum.enumValues);\nexport type StorageAssetVisibility = z.infer<typeof storageAssetVisibilitySchema>;\n\n/**\n * Create storageAsset\n */\nexport const createStorageAssetSchema = createInsertSchema(storageAssets);\n\nexport type CreateStorageAssetInput = z.input<typeof createStorageAssetSchema>;\nexport type CreateStorageAssetSchema = z.infer<typeof createStorageAssetSchema>;\n\n/**\n * Update storageAsset\n */\nexport const updateStorageAssetSchema = createUpdateSchema(storageAssets);\n\nexport type UpdateStorageAssetInput = z.input<typeof updateStorageAssetSchema>;\nexport type UpdateStorageAssetSchema = z.infer<typeof updateStorageAssetSchema>;\n\n/**\n * Select storageAsset\n */\nexport const selectStorageAssetSchema = createSelectSchema(storageAssets);\n\nexport type SelectStorageAssetSchema = z.infer<typeof selectStorageAssetSchema>;\n\nconst assetMetadataSchema = z.record(z.string(), z.string()).optional();\n\n/**\n * Upload schema\n */\nexport const uploadInputSchema = z.object({\n  name: z.string().min(1),\n  visibility: storageAssetVisibilitySchema.optional().default(\"private\"),\n  size: z.number().int().nonnegative().nullable().optional(),\n  contentType: z.string().nullable().optional(),\n  metadata: assetMetadataSchema,\n  body: objectBodyInputSchema,\n});\n\nexport const presignUploadInputSchema = z.object({\n  uploadId: z.uuid().optional(),\n  name: z.string().min(1),\n  visibility: storageAssetVisibilitySchema.optional().default(\"private\"),\n  size: z.number().int().nonnegative().nullable().optional(),\n  contentType: z.string().nullable().optional(),\n  metadata: assetMetadataSchema,\n});\n\nexport const presignUploadOutputSchema = selectStorageAssetSchema.extend({\n  presignedUrl: z.string(),\n});\n\nexport const confirmUploadInputSchema = z\n  .uuid()\n  .describe(\"The upload id of the pending upload to confirm, returned from the presign endpoint\");\n\nexport type UploadInput = z.input<typeof uploadInputSchema>;\nexport type PresignUploadInput = z.input<typeof presignUploadInputSchema>;\nexport type PresignUploadOutput = z.infer<typeof presignUploadOutputSchema>;\nexport type ConfirmUploadInput = z.input<typeof confirmUploadInputSchema>;\n\n/**\n * Get file url schema\n */\nexport const getAssetURLSchema = z.object({\n  disposition: z.enum(imageDispositions).optional().default(getObjectOptionsDefaults.disposition),\n});\n\nexport type GetAssetURLInput = z.input<typeof getAssetURLSchema>;\nexport type GetAssetURLSchema = z.infer<typeof getAssetURLSchema>;\n"],"mappings":";;;;;;;;;;AAcA,MAAa,+BAA+BA,IAAE,KAAK,2BAA2B,WAAW;;;;AAMzF,MAAa,2BAA2B,mBAAmB,cAAc;;;;AAQzE,MAAa,2BAA2B,mBAAmB,cAAc;;;;AAQzE,MAAa,2BAA2B,mBAAmB,cAAc;AAIzE,MAAM,sBAAsBA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,QAAQ,CAAC,CAAC,UAAU;;;;AAKvE,MAAa,oBAAoBA,IAAE,OAAO;CACxC,MAAMA,IAAE,QAAQ,CAAC,IAAI,EAAE;CACvB,YAAY,6BAA6B,UAAU,CAAC,QAAQ,UAAU;CACtE,MAAMA,IAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,UAAU;CAC1D,aAAaA,IAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CAC7C,UAAU;CACV,MAAM;CACP,CAAC;AAEF,MAAa,2BAA2BA,IAAE,OAAO;CAC/C,UAAUA,IAAE,MAAM,CAAC,UAAU;CAC7B,MAAMA,IAAE,QAAQ,CAAC,IAAI,EAAE;CACvB,YAAY,6BAA6B,UAAU,CAAC,QAAQ,UAAU;CACtE,MAAMA,IAAE,QAAQ,CAAC,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC,UAAU;CAC1D,aAAaA,IAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CAC7C,UAAU;CACX,CAAC;AAEF,MAAa,4BAA4B,yBAAyB,OAAO,EACvE,cAAcA,IAAE,QAAQ,EACzB,CAAC;AAEF,MAAa,2BAA2BA,IACrC,MAAM,CACN,SAAS,qFAAqF;;;;AAUjG,MAAa,oBAAoBA,IAAE,OAAO,EACxC,aAAaA,IAAE,KAAK,kBAAkB,CAAC,UAAU,CAAC,QAAQ,yBAAyB,YAAY,EAChG,CAAC"}

package/dist/modules/storage/providers/adapters/s3.server.d.mts

@@ -0,0 +1,19 @@
+import { StorageAdapter } from "../lib/types.mjs";
+import { S3ClientConfig } from "@aws-sdk/client-s3";
+
+//#region src/modules/storage/providers/adapters/s3.server.d.ts
+type StorageS3AdapterConfig = S3ClientConfig & {
+  bucketName: string;
+};
+/**
+ * S3 Storage Adapter
+ *
+ * This adapter implements the storage service interface using AWS S3 as the backend.
+ * It provides methods for uploading, retrieving, and managing files in an S3 bucket.
+ *
+ * @returns An instance of the S3StorageAdapter class.
+ */
+declare function storageS3Adapter(config: StorageS3AdapterConfig): StorageAdapter;
+//#endregion
+export { StorageS3AdapterConfig, storageS3Adapter };
+//# sourceMappingURL=s3.server.d.mts.map

package/dist/modules/storage/providers/adapters/s3.server.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3.server.d.mts","names":[],"sources":["../../../../../src/modules/storage/providers/adapters/s3.server.ts"],"mappings":";;;;KAwCY,sBAAA,GAAyB,cAAA;EACnC,UAAA;AAAA;;;;;AA6OF;;;;iBAAgB,gBAAA,CAAiB,MAAA,EAAQ,sBAAA,GAAyB,cAAA"}

package/dist/modules/storage/providers/adapters/s3.server.mjs

@@ -0,0 +1,173 @@
+import { getObjectInputSchema, getObjectOptionsSchema, getObjectOutputSchema, getObjectURLOptionsSchema, headObjectInputSchema, headObjectOutputSchema, putObjectInputSchema, putObjectOutputSchema, putObjectURLInputSchema, putObjectURLOptionsSchema } from "../lib/validators.mjs";
+import { StorageAdapterError } from "../lib/errors.mjs";
+import z from "zod";
+import { Readable } from "node:stream";
+import { DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+//#region src/modules/storage/providers/adapters/s3.server.ts
+/**
+* S3 Storage Adapter
+* This adapter implements the storage service interface using AWS S3 as the backend.
+* It provides methods for uploading, retrieving, and managing files in an S3 bucket.
+*/
+var StorageS3Adapter = class {
+	/**
+	* S3 Client
+	*/
+	key = "s3";
+	client;
+	bucketName;
+	/**
+	* Constructor
+	*/
+	constructor({ bucketName, ...config }) {
+		this.client = new S3Client(config);
+		this.bucketName = bucketName;
+	}
+	/**
+	* Create get command
+	*/
+	#createGetCommand(input, options = {}) {
+		const key = getObjectInputSchema.parse(input);
+		const { disposition } = getObjectOptionsSchema.parse(options);
+		return new GetObjectCommand({
+			Bucket: this.bucketName,
+			Key: key,
+			ResponseContentDisposition: disposition
+		});
+	}
+	/**
+	* Get object
+	*/
+	async getObject(input, options = {}) {
+		const getCommand = this.#createGetCommand(input, options);
+		const result = await this.client.send(getCommand);
+		if (result.Body == null) throw new StorageAdapterError("OBJECT_NOT_READABLE", "Object body is missing", { cause: /* @__PURE__ */ new Error(`ContentLength: ${result.ContentLength}, ContentType: ${result.ContentType}, Body: ${result.Body}`) });
+		return getObjectOutputSchema.parse({
+			contentType: result.ContentType,
+			size: result.ContentLength,
+			metadata: result.Metadata,
+			body: this.#toReadable(result.Body)
+		});
+	}
+	/**
+	* Get object URL
+	*/
+	async getObjectURL(input, options = {}) {
+		const { expiresIn } = getObjectURLOptionsSchema.parse(options);
+		const getCommand = this.#createGetCommand(input, options);
+		return await getSignedUrl(this.client, getCommand, { expiresIn });
+	}
+	/**
+	* Create head command
+	*/
+	#createHeadCommand(input) {
+		const { key } = headObjectInputSchema.parse(input);
+		return new HeadObjectCommand({
+			Bucket: this.bucketName,
+			Key: key
+		});
+	}
+	/**
+	* Head object
+	*/
+	async headObject(input) {
+		const headCommand = this.#createHeadCommand(input);
+		const result = await this.client.send(headCommand);
+		if (result.ContentLength == null || result.ContentType == null) throw new StorageAdapterError("OBJECT_NOT_FOUND", "Object metadata could not be resolved", { cause: /* @__PURE__ */ new Error(`ContentLength: ${result.ContentLength}, ContentType: ${result.ContentType}`) });
+		return headObjectOutputSchema.parse({
+			contentType: result.ContentType,
+			size: result.ContentLength,
+			metadata: result.Metadata
+		});
+	}
+	/**
+	* Create put command
+	*/
+	#createPutCommand(data) {
+		return new PutObjectCommand({
+			Bucket: this.bucketName,
+			Key: data.key,
+			Body: "body" in data ? data.body : void 0,
+			ContentType: data.contentType ?? void 0,
+			ContentLength: data.size ?? void 0,
+			Metadata: data.metadata ?? void 0
+		});
+	}
+	/**
+	* Put object
+	*/
+	async putObject(input) {
+		const data = putObjectInputSchema.parse(input);
+		const putCommand = this.#createPutCommand(data);
+		const result = await this.client.send(putCommand);
+		return putObjectOutputSchema.parse({ size: result.Size });
+	}
+	/**
+	* Get signed URL
+	*/
+	async putObjectURL(input, options = {}) {
+		const { expiresIn } = putObjectURLOptionsSchema.parse(options);
+		const data = putObjectURLInputSchema.parse(input);
+		const putCommand = this.#createPutCommand(data);
+		return await getSignedUrl(this.client, putCommand, { expiresIn });
+	}
+	/**
+	* Delete object
+	*/
+	async deleteObject(input) {
+		const key = z.string().parse(input);
+		const deleteCommand = new DeleteObjectCommand({
+			Bucket: this.bucketName,
+			Key: key
+		});
+		const response = await this.client.send(deleteCommand);
+		if (response.DeleteMarker !== true && response.VersionId) throw new StorageAdapterError("OBJECT_DELETE_FAILED", "Failed to delete object", { cause: /* @__PURE__ */ new Error(`DeleteMarker: ${response.DeleteMarker}, VersionId: ${response.VersionId}`) });
+	}
+	/**
+	* Delete multiple objects
+	*/
+	async deleteObjects(input) {
+		const keys = z.array(z.string()).parse(input);
+		const deleteCommand = new DeleteObjectsCommand({
+			Bucket: this.bucketName,
+			Delete: { Objects: keys.map((Key) => ({ Key })) }
+		});
+		const response = await this.client.send(deleteCommand);
+		if (response.Errors && response.Errors.length > 0) throw new StorageAdapterError("OBJECT_DELETE_FAILED", "Failed to delete objects", { cause: new Error(JSON.stringify(response.Errors)) });
+	}
+	/**
+	* Transform the GetObjectCommandOutput Body into a normalized Readable stream
+	* S3 can return the Body in different formats depending on the environment and AWS SDK version:
+	* - In Node.js, it may return a Readable stream.
+	* - In newer AWS SDK versions in Node 18+, it may return a web ReadableStream with transformToWebStream method.
+	* - In older AWS SDK versions in Node 16, it may return a web ReadableStream without transformToWebStream.
+	* - It may also return a string, Buffer, or Uint8Array for small objects.
+	*
+	* This method normalizes all these cases into a Node.js Readable stream for consistent handling in the application.
+	*/
+	#toReadable(body) {
+		if (!body) throw new StorageAdapterError("OBJECT_NOT_READABLE", "S3 object body is empty");
+		if (body instanceof Readable) return body;
+		if (typeof body.transformToWebStream === "function") return Readable.fromWeb(body.transformToWebStream());
+		if (typeof body.getReader === "function") return Readable.fromWeb(body);
+		if (typeof body === "string" || body instanceof Uint8Array || Buffer.isBuffer(body)) return Readable.from([body]);
+		throw new StorageAdapterError("UNSUPPORTED_BODY_TYPE", "Unsupported object body type");
+	}
+};
+/**
+* S3 Storage Adapter
+*
+* This adapter implements the storage service interface using AWS S3 as the backend.
+* It provides methods for uploading, retrieving, and managing files in an S3 bucket.
+*
+* @returns An instance of the S3StorageAdapter class.
+*/
+function storageS3Adapter(config) {
+	return new StorageS3Adapter(config);
+}
+
+//#endregion
+export { storageS3Adapter };
+//# sourceMappingURL=s3.server.mjs.map

package/dist/modules/storage/providers/adapters/s3.server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3.server.mjs","names":["#createGetCommand","#toReadable","#createHeadCommand","#createPutCommand"],"sources":["../../../../../src/modules/storage/providers/adapters/s3.server.ts"],"sourcesContent":["import { Readable } from \"node:stream\";\nimport type { ReadableStream } from \"node:stream/web\";\nimport {\n  DeleteObjectCommand,\n  DeleteObjectsCommand,\n  GetObjectCommand,\n  type GetObjectCommandOutput,\n  HeadObjectCommand,\n  PutObjectCommand,\n  S3Client,\n  type S3ClientConfig,\n} from \"@aws-sdk/client-s3\";\nimport { getSignedUrl } from \"@aws-sdk/s3-request-presigner\";\nimport z from \"zod\";\nimport type { StorageProvider } from \"../lib/constants\";\nimport { StorageAdapterError } from \"../lib/errors\";\nimport type { StorageAdapter } from \"../lib/types\";\nimport {\n  type GetObjectInput,\n  type GetObjectOptions,\n  type GetObjectOutput,\n  type GetObjectURLOptions,\n  getObjectInputSchema,\n  getObjectOptionsSchema,\n  getObjectOutputSchema,\n  getObjectURLOptionsSchema,\n  type HeadObjectInput,\n  type HeadObjectOutput,\n  headObjectInputSchema,\n  headObjectOutputSchema,\n  type PutObjectInput,\n  type PutObjectOutput,\n  type PutObjectURLInput,\n  type PutObjectURLOptions,\n  putObjectInputSchema,\n  putObjectOutputSchema,\n  putObjectURLInputSchema,\n  putObjectURLOptionsSchema,\n} from \"../lib/validators\";\n\nexport type StorageS3AdapterConfig = S3ClientConfig & {\n  bucketName: string;\n};\n\n/**\n * S3 Storage Adapter\n * This adapter implements the storage service interface using AWS S3 as the backend.\n * It provides methods for uploading, retrieving, and managing files in an S3 bucket.\n */\nclass StorageS3Adapter implements StorageAdapter {\n  /**\n   * S3 Client\n   */\n  key: StorageProvider = \"s3\";\n  client: S3Client;\n  bucketName: string;\n\n  /**\n   * Constructor\n   */\n  constructor({ bucketName, ...config }: StorageS3AdapterConfig) {\n    this.client = new S3Client(config);\n    this.bucketName = bucketName;\n  }\n\n  /**\n   * Create get command\n   */\n  #createGetCommand(input: GetObjectInput, options: GetObjectOptions = {}) {\n    const key = getObjectInputSchema.parse(input);\n    const { disposition } = getObjectOptionsSchema.parse(options);\n\n    return new GetObjectCommand({\n      Bucket: this.bucketName,\n      Key: key,\n      ResponseContentDisposition: disposition,\n    });\n  }\n\n  /**\n   * Get object\n   */\n  async getObject(input: GetObjectInput, options: GetObjectOptions = {}): Promise<GetObjectOutput> {\n    const getCommand = this.#createGetCommand(input, options);\n\n    const result = await this.client.send(getCommand);\n\n    if (result.Body == null) {\n      throw new StorageAdapterError(\"OBJECT_NOT_READABLE\", \"Object body is missing\", {\n        cause: new Error(\n          `ContentLength: ${result.ContentLength}, ContentType: ${result.ContentType}, Body: ${result.Body}`,\n        ),\n      });\n    }\n\n    return getObjectOutputSchema.parse({\n      contentType: result.ContentType,\n      size: result.ContentLength,\n      metadata: result.Metadata,\n      body: this.#toReadable(result.Body),\n    });\n  }\n\n  /**\n   * Get object URL\n   */\n  async getObjectURL(input: GetObjectInput, options: GetObjectURLOptions = {}) {\n    const { expiresIn } = getObjectURLOptionsSchema.parse(options);\n\n    // Validate input and create get command\n    const getCommand = this.#createGetCommand(input, options);\n\n    // Generate the presigned url\n    return await getSignedUrl(this.client, getCommand, { expiresIn });\n  }\n\n  /**\n   * Create head command\n   */\n  #createHeadCommand(input: HeadObjectInput) {\n    const { key } = headObjectInputSchema.parse(input);\n\n    return new HeadObjectCommand({\n      Bucket: this.bucketName,\n      Key: key,\n    });\n  }\n\n  /**\n   * Head object\n   */\n  async headObject(input: HeadObjectInput): Promise<HeadObjectOutput> {\n    const headCommand = this.#createHeadCommand(input);\n\n    const result = await this.client.send(headCommand);\n\n    if (result.ContentLength == null || result.ContentType == null) {\n      throw new StorageAdapterError(\"OBJECT_NOT_FOUND\", \"Object metadata could not be resolved\", {\n        cause: new Error(\n          `ContentLength: ${result.ContentLength}, ContentType: ${result.ContentType}`,\n        ),\n      });\n    }\n\n    return headObjectOutputSchema.parse({\n      contentType: result.ContentType,\n      size: result.ContentLength,\n      metadata: result.Metadata,\n    });\n  }\n\n  /**\n   * Create put command\n   */\n  #createPutCommand(\n    data: z.infer<typeof putObjectInputSchema> | z.infer<typeof putObjectURLInputSchema>,\n  ) {\n    return new PutObjectCommand({\n      Bucket: this.bucketName,\n      Key: data.key,\n      Body: \"body\" in data ? data.body : undefined,\n      ContentType: data.contentType ?? undefined,\n      ContentLength: data.size ?? undefined,\n      Metadata: data.metadata ?? undefined,\n    });\n  }\n\n  /**\n   * Put object\n   */\n  async putObject(input: PutObjectInput): Promise<PutObjectOutput> {\n    const data = putObjectInputSchema.parse(input);\n    const putCommand = this.#createPutCommand(data);\n\n    const result = await this.client.send(putCommand);\n\n    return putObjectOutputSchema.parse({ size: result.Size });\n  }\n\n  /**\n   * Get signed URL\n   */\n  async putObjectURL(input: PutObjectURLInput, options: PutObjectURLOptions = {}) {\n    const { expiresIn } = putObjectURLOptionsSchema.parse(options);\n\n    // Validate input and create put command\n    const data = putObjectURLInputSchema.parse(input);\n    const putCommand = this.#createPutCommand(data);\n\n    // Generate the presigned url\n    return await getSignedUrl(this.client, putCommand, { expiresIn });\n  }\n\n  /**\n   * Delete object\n   */\n  async deleteObject(input: string): Promise<void> {\n    const key = z.string().parse(input);\n\n    const deleteCommand = new DeleteObjectCommand({\n      Bucket: this.bucketName,\n      Key: key,\n    });\n\n    const response = await this.client.send(deleteCommand);\n\n    if (response.DeleteMarker !== true && response.VersionId) {\n      throw new StorageAdapterError(\"OBJECT_DELETE_FAILED\", \"Failed to delete object\", {\n        cause: new Error(\n          `DeleteMarker: ${response.DeleteMarker}, VersionId: ${response.VersionId}`,\n        ),\n      });\n    }\n  }\n\n  /**\n   * Delete multiple objects\n   */\n  async deleteObjects(input: string[]): Promise<void> {\n    const keys = z.array(z.string()).parse(input);\n\n    const deleteCommand = new DeleteObjectsCommand({\n      Bucket: this.bucketName,\n      Delete: { Objects: keys.map((Key) => ({ Key })) },\n    });\n\n    const response = await this.client.send(deleteCommand);\n\n    if (response.Errors && response.Errors.length > 0) {\n      throw new StorageAdapterError(\"OBJECT_DELETE_FAILED\", \"Failed to delete objects\", {\n        cause: new Error(JSON.stringify(response.Errors)),\n      });\n    }\n  }\n\n  /**\n   * Transform the GetObjectCommandOutput Body into a normalized Readable stream\n   * S3 can return the Body in different formats depending on the environment and AWS SDK version:\n   * - In Node.js, it may return a Readable stream.\n   * - In newer AWS SDK versions in Node 18+, it may return a web ReadableStream with transformToWebStream method.\n   * - In older AWS SDK versions in Node 16, it may return a web ReadableStream without transformToWebStream.\n   * - It may also return a string, Buffer, or Uint8Array for small objects.\n   *\n   * This method normalizes all these cases into a Node.js Readable stream for consistent handling in the application.\n   */\n  #toReadable(body: GetObjectCommandOutput[\"Body\"]): Readable {\n    if (!body) throw new StorageAdapterError(\"OBJECT_NOT_READABLE\", \"S3 object body is empty\");\n\n    // If it's already a Node Readable, return as is\n    if (body instanceof Readable) return body;\n\n    if (typeof body.transformToWebStream === \"function\") {\n      // biome-ignore lint/suspicious/noExplicitAny: The AWS SDK v3 in Node 18+ returns a web ReadableStream with a transformToWebStream method, but the types don't reflect this correctly, so we need to use 'any' here.\n      return Readable.fromWeb((body as any).transformToWebStream());\n    }\n\n    // biome-ignore lint/suspicious/noExplicitAny: The AWS SDK v3 in Node 16 returns a web ReadableStream without a transformToWebStream method, but the types don't reflect this correctly, so we need to use 'any' here.\n    if (typeof (body as any).getReader === \"function\") {\n      return Readable.fromWeb(body as unknown as ReadableStream);\n    }\n\n    // If it's a string, Buffer, or Uint8Array, convert to Readable\n    if (typeof body === \"string\" || body instanceof Uint8Array || Buffer.isBuffer(body)) {\n      return Readable.from([body]);\n    }\n\n    throw new StorageAdapterError(\"UNSUPPORTED_BODY_TYPE\", \"Unsupported object body type\");\n  }\n}\n\n/**\n * S3 Storage Adapter\n *\n * This adapter implements the storage service interface using AWS S3 as the backend.\n * It provides methods for uploading, retrieving, and managing files in an S3 bucket.\n *\n * @returns An instance of the S3StorageAdapter class.\n */\nexport function storageS3Adapter(config: StorageS3AdapterConfig): StorageAdapter {\n  return new StorageS3Adapter(config);\n}\n"],"mappings":"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"}

package/dist/modules/storage/providers/lib/constants.d.mts

@@ -0,0 +1,6 @@
+//#region src/modules/storage/providers/lib/constants.d.ts
+declare const storageProviders: readonly ["s3"];
+type StorageProvider = (typeof storageProviders)[number];
+//#endregion
+export { StorageProvider, storageProviders };
+//# sourceMappingURL=constants.d.mts.map

package/dist/modules/storage/providers/lib/constants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../../../../../src/modules/storage/providers/lib/constants.ts"],"mappings":";cACa,gBAAA;AAAA,KACD,eAAA,WAA0B,gBAAA"}

package/dist/modules/storage/providers/lib/constants.mjs

@@ -0,0 +1,6 @@
+//#region src/modules/storage/providers/lib/constants.ts
+const storageProviders = ["s3"];
+
+//#endregion
+export { storageProviders };
+//# sourceMappingURL=constants.mjs.map

package/dist/modules/storage/providers/lib/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../../../../src/modules/storage/providers/lib/constants.ts"],"sourcesContent":["// Storage providers\nexport const storageProviders = [\"s3\"] as const;\nexport type StorageProvider = (typeof storageProviders)[number];\n"],"mappings":";AACA,MAAa,mBAAmB,CAAC,KAAK"}

package/dist/modules/storage/providers/lib/errors.d.mts

@@ -0,0 +1,12 @@
+//#region src/modules/storage/providers/lib/errors.d.ts
+/**
+ * Storage adapter error codes and class
+ */
+type StorageAdapterErrorCode = "OBJECT_NOT_FOUND" | "OBJECT_NOT_READABLE" | "OBJECT_DELETE_FAILED" | "OBJECT_HEAD_FAILED" | "OBJECT_UPLOAD_FAILED" | "OBJECT_URL_FAILED" | "UNSUPPORTED_BODY_TYPE";
+declare class StorageAdapterError extends Error {
+  code: StorageAdapterErrorCode;
+  constructor(code: StorageAdapterErrorCode, message: string, options?: ErrorOptions);
+}
+//#endregion
+export { StorageAdapterError, StorageAdapterErrorCode };
+//# sourceMappingURL=errors.d.mts.map

package/dist/modules/storage/providers/lib/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../../../../src/modules/storage/providers/lib/errors.ts"],"mappings":";;AAGA;;KAAY,uBAAA;AAAA,cASC,mBAAA,SAA4B,KAAA;EACvC,IAAA,EAAM,uBAAA;cAEM,IAAA,EAAM,uBAAA,EAAyB,OAAA,UAAiB,OAAA,GAAU,YAAA;AAAA"}

package/dist/modules/storage/providers/lib/errors.mjs

@@ -0,0 +1,13 @@
+//#region src/modules/storage/providers/lib/errors.ts
+var StorageAdapterError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "StorageError";
+		this.code = code;
+	}
+};
+
+//#endregion
+export { StorageAdapterError };
+//# sourceMappingURL=errors.mjs.map

package/dist/modules/storage/providers/lib/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../../../src/modules/storage/providers/lib/errors.ts"],"sourcesContent":["/**\n * Storage adapter error codes and class\n */\nexport type StorageAdapterErrorCode =\n  | \"OBJECT_NOT_FOUND\"\n  | \"OBJECT_NOT_READABLE\"\n  | \"OBJECT_DELETE_FAILED\"\n  | \"OBJECT_HEAD_FAILED\"\n  | \"OBJECT_UPLOAD_FAILED\"\n  | \"OBJECT_URL_FAILED\"\n  | \"UNSUPPORTED_BODY_TYPE\";\n\nexport class StorageAdapterError extends Error {\n  code: StorageAdapterErrorCode;\n\n  constructor(code: StorageAdapterErrorCode, message: string, options?: ErrorOptions) {\n    super(message, options);\n    this.name = \"StorageError\";\n    this.code = code;\n  }\n}\n"],"mappings":";AAYA,IAAa,sBAAb,cAAyC,MAAM;CAC7C;CAEA,YAAY,MAA+B,SAAiB,SAAwB;AAClF,QAAM,SAAS,QAAQ;AACvB,OAAK,OAAO;AACZ,OAAK,OAAO"}

package/dist/modules/storage/providers/lib/types.d.mts

@@ -0,0 +1,21 @@
+import { StorageProvider } from "./constants.mjs";
+import { GetObjectInput, GetObjectOptions, GetObjectOutput, GetObjectURLOptions, HeadObjectInput, HeadObjectOutput, PutObjectInput, PutObjectOutput, PutObjectURLInput, PutObjectURLOptions } from "./validators.mjs";
+
+//#region src/modules/storage/providers/lib/types.d.ts
+/**
+ * Storage adapter interface
+ */
+interface StorageAdapter {
+  key: StorageProvider;
+  bucketName: string;
+  getObject: (input: GetObjectInput, options?: GetObjectOptions) => Promise<GetObjectOutput>;
+  getObjectURL: (input: GetObjectInput, options?: GetObjectURLOptions) => Promise<string>;
+  headObject: (input: HeadObjectInput) => Promise<HeadObjectOutput>;
+  putObject: (props: PutObjectInput) => Promise<PutObjectOutput>;
+  putObjectURL: (props: PutObjectURLInput, options?: PutObjectURLOptions) => Promise<string>;
+  deleteObject: (key: string) => Promise<void>;
+  deleteObjects: (keys: string[]) => Promise<void>;
+}
+//#endregion
+export { StorageAdapter };
+//# sourceMappingURL=types.d.mts.map

package/dist/modules/storage/providers/lib/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../src/modules/storage/providers/lib/types.ts"],"mappings":";;;;;;AAiBA;UAAiB,cAAA;EACf,GAAA,EAAK,eAAA;EACL,UAAA;EACA,SAAA,GAAY,KAAA,EAAO,cAAA,EAAgB,OAAA,GAAU,gBAAA,KAAqB,OAAA,CAAQ,eAAA;EAC1E,YAAA,GAAe,KAAA,EAAO,cAAA,EAAgB,OAAA,GAAU,mBAAA,KAAwB,OAAA;EACxE,UAAA,GAAa,KAAA,EAAO,eAAA,KAAoB,OAAA,CAAQ,gBAAA;EAChD,SAAA,GAAY,KAAA,EAAO,cAAA,KAAmB,OAAA,CAAQ,eAAA;EAC9C,YAAA,GAAe,KAAA,EAAO,iBAAA,EAAmB,OAAA,GAAU,mBAAA,KAAwB,OAAA;EAC3E,YAAA,GAAe,GAAA,aAAgB,OAAA;EAC/B,aAAA,GAAgB,IAAA,eAAmB,OAAA;AAAA"}

package/dist/modules/storage/providers/lib/validators.d.mts

@@ -0,0 +1,112 @@
+import { z as z$1 } from "zod";
+import { Readable } from "node:stream";
+
+//#region src/modules/storage/providers/lib/validators.d.ts
+/**
+ * Object body schema
+ */
+declare const objectBodyInputSchema: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z$1.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, z$1.ZodCustom<Readable, Readable>]>;
+type ObjectBodyInput = z$1.infer<typeof objectBodyInputSchema>;
+/**
+ * Object body output schema (normalized)
+ */
+declare const objectBodyOutputSchema: z$1.ZodCustom<Readable, Readable>;
+type ObjectBodyOutput = z$1.infer<typeof objectBodyOutputSchema>;
+/**
+ * Object schema
+ */
+declare const objectSchema: z$1.ZodObject<{
+  contentType: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  size: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+}, z$1.core.$strip>;
+type ObjectSchema = z$1.infer<typeof objectSchema>;
+/**
+ * Get object input
+ */
+declare const getObjectInputSchema: z$1.ZodString;
+type GetObjectInput = z$1.input<typeof getObjectInputSchema>;
+/**
+ * Get object options schema
+ */
+declare const getObjectOptionsDefaults: {
+  readonly disposition: "inline";
+};
+declare const getObjectOptionsSchema: z$1.ZodObject<{
+  disposition: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+}, z$1.core.$strip>;
+type GetObjectOptions = z$1.input<typeof getObjectOptionsSchema>;
+/**
+ * Get object URL input
+ */
+declare const getObjectURLOptionsSchema: z$1.ZodObject<{
+  disposition: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+  expiresIn: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+}, z$1.core.$strip>;
+type GetObjectURLOptions = z$1.input<typeof getObjectURLOptionsSchema>;
+/**
+ * Get object output
+ */
+declare const getObjectOutputSchema: z$1.ZodObject<{
+  contentType: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  size: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+  body: z$1.ZodCustom<Readable, Readable>;
+}, z$1.core.$strip>;
+type GetObjectOutput = z$1.infer<typeof getObjectOutputSchema>;
+/**
+ * Get object head input
+ */
+declare const headObjectInputSchema: z$1.ZodObject<{
+  key: z$1.ZodString;
+}, z$1.core.$strip>;
+type HeadObjectInput = z$1.input<typeof headObjectInputSchema>;
+/**
+ * Head object output
+ */
+declare const headObjectOutputSchema: z$1.ZodObject<{
+  contentType: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  size: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+}, z$1.core.$strip>;
+type HeadObjectOutput = z$1.infer<typeof headObjectOutputSchema>;
+/**
+ * Put object URL input
+ */
+declare const putObjectURLInputSchema: z$1.ZodObject<{
+  key: z$1.ZodString;
+  contentType: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  size: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+}, z$1.core.$strip>;
+type PutObjectURLInput = z$1.input<typeof putObjectURLInputSchema>;
+/**
+ * Put object URL input
+ */
+declare const putObjectURLOptionsSchema: z$1.ZodObject<{
+  expiresIn: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+}, z$1.core.$strip>;
+type PutObjectURLOptions = z$1.input<typeof putObjectURLOptionsSchema>;
+/**
+ * Put object input
+ */
+declare const putObjectInputSchema: z$1.ZodObject<{
+  key: z$1.ZodString;
+  contentType: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  size: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+  body: z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z$1.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, z$1.ZodCustom<Readable, Readable>]>;
+}, z$1.core.$strip>;
+type PutObjectInput = z$1.input<typeof putObjectInputSchema>;
+/**
+ * Put object schema
+ */
+declare const putObjectOutputSchema: z$1.ZodObject<{
+  contentType: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+  size: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodNumber>>;
+  metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+}, z$1.core.$strip>;
+type PutObjectOutput = z$1.infer<typeof putObjectOutputSchema>;
+//#endregion
+export { GetObjectInput, GetObjectOptions, GetObjectOutput, GetObjectURLOptions, HeadObjectInput, HeadObjectOutput, ObjectBodyInput, ObjectBodyOutput, ObjectSchema, PutObjectInput, PutObjectOutput, PutObjectURLInput, PutObjectURLOptions, getObjectInputSchema, getObjectOptionsDefaults, getObjectOptionsSchema, getObjectOutputSchema, getObjectURLOptionsSchema, headObjectInputSchema, headObjectOutputSchema, objectBodyInputSchema, objectBodyOutputSchema, objectSchema, putObjectInputSchema, putObjectOutputSchema, putObjectURLInputSchema, putObjectURLOptionsSchema };
+//# sourceMappingURL=validators.d.mts.map

package/dist/modules/storage/providers/lib/validators.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.mts","names":[],"sources":["../../../../../src/modules/storage/providers/lib/validators.ts"],"mappings":";;;;;;AAMA;cAAa,qBAAA,EAAqB,GAAA,CAAA,QAAA,WAAA,GAAA,CAAA,SAAA,EAAA,GAAA,CAAA,SAAA,CAAA,UAAA,CAAA,WAAA,GAAA,UAAA,CAAA,WAAA,IAAA,GAAA,CAAA,SAAA,CAAA,MAAA,CAAA,eAAA,GAAA,MAAA,CAAA,eAAA,IAAA,GAAA,CAAA,SAAA,CAAA,QAAA,EAAA,QAAA;AAAA,KAOtB,eAAA,GAAkB,GAAA,CAAE,KAAA,QAAa,qBAAA;;;;cAKhC,sBAAA,EAAsB,GAAA,CAAA,SAAA,CAAA,QAAA,EAAA,QAAA;AAAA,KAEvB,gBAAA,GAAmB,GAAA,CAAE,KAAA,QAAa,sBAAA;;;;cAKjC,YAAA,EAAY,GAAA,CAAA,SAAA;;;;;KAMb,YAAA,GAAe,GAAA,CAAE,KAAA,QAAa,YAAA;;;;cAK7B,oBAAA,EAAoB,GAAA,CAAA,SAAA;AAAA,KACrB,cAAA,GAAiB,GAAA,CAAE,KAAA,QAAa,oBAAA;;;;cAK/B,wBAAA;EAAA,SAA6D,WAAA;AAAA;AAAA,cAE7D,sBAAA,EAAsB,GAAA,CAAA,SAAA;;;KAIvB,gBAAA,GAAmB,GAAA,CAAE,KAAA,QAAa,sBAAA;;;;cAKjC,yBAAA,EAAyB,GAAA,CAAA,SAAA;;;;KAO1B,mBAAA,GAAsB,GAAA,CAAE,KAAA,QAAa,yBAAA;;;AA/CjD;cAoDa,qBAAA,EAAqB,GAAA,CAAA,SAAA;;;;;;KAItB,eAAA,GAAkB,GAAA,CAAE,KAAA,QAAa,qBAAA;;AAnD7C;;cAwDa,qBAAA,EAAqB,GAAA,CAAA,SAAA;;;KAItB,eAAA,GAAkB,GAAA,CAAE,KAAA,QAAa,qBAAA;;;;cAKhC,sBAAA,EAAsB,GAAA,CAAA,SAAA;;;;;KAEvB,gBAAA,GAAmB,GAAA,CAAE,KAAA,QAAa,sBAAA;;;;cAKjC,uBAAA,EAAuB,GAAA,CAAA,SAAA;;;;;;KAOxB,iBAAA,GAAoB,GAAA,CAAE,KAAA,QAAa,uBAAA;;;;cAKlC,yBAAA,EAAyB,GAAA,CAAA,SAAA;;;KAI1B,mBAAA,GAAsB,GAAA,CAAE,KAAA,QAAa,yBAAA;;;;cAKpC,oBAAA,EAAoB,GAAA,CAAA,SAAA;;;;;;;KAIrB,cAAA,GAAiB,GAAA,CAAE,KAAA,QAAa,oBAAA;;;;cAK/B,qBAAA,EAAqB,GAAA,CAAA,SAAA;;;;;KACtB,eAAA,GAAkB,GAAA,CAAE,KAAA,QAAa,qBAAA"}