appos 0.3.2-0 → 0.3.3-0

package/dist/exports/api/workflows/api/event.mjs

@@ -1 +1,126 @@
-import"./redis.mjs";import"../constants.mjs";import{z as e}from"zod";import{join as t}from"node:path";import"es-toolkit";function n(e){let t=null,n=null;return{inputSchema:e.input,get name(){return n},register(e,r){t=e,n=r},async emit(r){if(!t||!n)throw Error(`Event not registered. Ensure the worker is started before emitting events.`);let i=e.input.parse(r),a={container:t,input:i};await e.run(a),t.eventBus.publish(n,i).catch(e=>{t.logger.error({err:e,event:n},`Redis publish failed`)})},async subscribe(r){if(!t||!n)throw Error(`Event not registered. Ensure the worker is started before subscribing.`);return t.eventBus.subscribe(n,async i=>{let a=e.input.parse(i),o={container:t,input:a};try{await r(o)}catch(e){t.logger.error({err:e,event:n},`Event subscription handler error`)}})}}}const r=n({input:e.object({action:e.enum([`INSERT`,`UPDATE`,`DELETE`]),newData:e.record(e.string(),e.unknown()).nullable(),oldData:e.record(e.string(),e.unknown()).nullable(),organizationId:e.string().nullable(),tableName:e.string(),timestamp:e.string(),userId:e.string().nullable()}),async run(){}});export{r as dbChangesEvent};
+import "./redis.mjs";
+import "../constants.mjs";
+import { z } from "zod";
+import { join } from "node:path";
+import "es-toolkit";
+
+//#region src/api/event.ts
+/**
+* Defines a type-safe event with in-memory and Redis pub/sub support.
+*
+* Algorithm:
+* 1. Define event with input schema and in-memory run handler
+* 2. On emit(): validate input, run in-memory handler, publish to Redis (fire-and-forget)
+* 3. .subscribe() creates Redis subscription for tRPC/SSE/WebSocket handlers
+*
+* @example
+* ```typescript
+* // api/events/order-status.ts
+* export default defineEvent({
+*   input: z.object({
+*     orderId: z.string(),
+*     status: z.enum(["pending", "shipped", "delivered"]),
+*   }),
+*   async run(ctx) {
+*     ctx.container.logger.info(`Order ${ctx.input.orderId} is ${ctx.input.status}`);
+*   },
+* });
+*
+* // Emit from anywhere
+* await orderStatus.emit({ orderId: "123", status: "shipped" });
+*
+* // Subscribe (e.g., in tRPC router)
+* const unsubscribe = await orderStatus.subscribe(async (ctx) => {
+*   // Push to client via SSE/WebSocket
+* });
+* // Cleanup when client disconnects
+* unsubscribe();
+* ```
+*/
+function defineEvent(options) {
+	let container = null;
+	let eventName = null;
+	return {
+		inputSchema: options.input,
+		get name() {
+			return eventName;
+		},
+		register(c, name) {
+			container = c;
+			eventName = name;
+		},
+		async emit(input) {
+			if (!container || !eventName) throw new Error("Event not registered. Ensure the worker is started before emitting events.");
+			const validated = options.input.parse(input);
+			const ctx = {
+				container,
+				input: validated
+			};
+			await options.run(ctx);
+			container.eventBus.publish(eventName, validated).catch((err) => {
+				container.logger.error({
+					err,
+					event: eventName
+				}, "Redis publish failed");
+			});
+		},
+		async subscribe(handler) {
+			if (!container || !eventName) throw new Error("Event not registered. Ensure the worker is started before subscribing.");
+			return container.eventBus.subscribe(eventName, async (message) => {
+				const validated = options.input.parse(message);
+				const ctx = {
+					container,
+					input: validated
+				};
+				try {
+					await handler(ctx);
+				} catch (err) {
+					container.logger.error({
+						err,
+						event: eventName
+					}, "Event subscription handler error");
+				}
+			});
+		}
+	};
+}
+/**
+* Input schema for dbChangesEvent.
+*/
+const dbChangeInputSchema = z.object({
+	action: z.enum([
+		"INSERT",
+		"UPDATE",
+		"DELETE"
+	]),
+	newData: z.record(z.string(), z.unknown()).nullable(),
+	oldData: z.record(z.string(), z.unknown()).nullable(),
+	organizationId: z.string().nullable(),
+	tableName: z.string(),
+	timestamp: z.string(),
+	userId: z.string().nullable()
+});
+/**
+* Built-in event for database changes.
+* Emitted by trackDbChanges workflow.
+*
+* @example
+* ```typescript
+* // Subscribe to DB changes (e.g., in tRPC subscription)
+* import { dbChangesEvent } from "appos/api";
+*
+* const unsubscribe = await dbChangesEvent.subscribe(async (ctx) => {
+*   wsServer.publish("db-changes", JSON.stringify(ctx.input));
+* });
+*
+* // Cleanup when done
+* unsubscribe();
+* ```
+*/
+const dbChangesEvent = defineEvent({
+	input: dbChangeInputSchema,
+	async run() {}
+});
+
+//#endregion
+export { dbChangesEvent };

package/dist/exports/api/workflows/api/redis.mjs

@@ -1 +1,3 @@
-import"redis";export{};
+import "redis";
+
+export {  };

package/dist/exports/api/workflows/api/workflow.mjs

@@ -1 +1,135 @@
-import"../constants.mjs";import{join as e}from"node:path";import"es-toolkit";function t(e){let t=null,n=null,r=null,i=null,a=async i=>{if(!t||!r)throw Error(`Workflow "${n}" not registered`);let a=r,o=a.workflowID;if(!o)throw Error(`DBOS.workflowID is not available in this context`);let s={container:t,workflowId:o,input:i,step:(e,t)=>a.runStep(t,{name:e})};return e.run(s)};return{inputSchema:e.input,get name(){return n},register(o,s,c){t=o,n=s,r=c,i=c.registerWorkflow(a,{name:s,...e.config})},async start(t){if(!i||!n||!r)throw Error(`Workflow not registered. Ensure the worker is started before triggering workflows.`);let a=e.input.parse(t),o=await r.startWorkflow(i)(a);return{workflowId:o.workflowID,getStatus:()=>o.getStatus(),getResult:()=>o.getResult()}}}}function n(e){let t=null,n=null,r=null,i=async(i,a)=>{if(!t||!r)throw Error(`Workflow "${n}" not registered`);let o=r,s=o.workflowID;if(!s)throw Error(`DBOS.workflowID is not available in this context`);let c={container:t,workflowId:s,scheduledTime:i,step:(e,t)=>o.runStep(t,{name:e})};return e.run(c)};return{crontab:e.crontab,get name(){return n},register(a,o,s){t=a,n=o,r=s,s.registerScheduled(s.registerWorkflow(i,{name:o}),{crontab:e.crontab})}}}export{n as defineScheduledWorkflow,t as defineWorkflow};
+import "../constants.mjs";
+import { join } from "node:path";
+import "es-toolkit";
+
+//#region src/api/workflow.ts
+/**
+* Defines a durable workflow that can be triggered with type-safe input.
+*
+* Workflows are:
+* - Durable: Automatically resume after crashes or restarts
+* - Type-safe: Input and output types are inferred from the schema
+* - Container-aware: Access to db, mailer, logger via ctx.container
+*
+* @example
+* ```typescript
+* // api/workflows/send-welcome-email.ts
+* export default defineWorkflow({
+*   input: z.object({
+*     userId: z.string(),
+*     email: z.string().email(),
+*   }),
+*   async run(ctx) {
+*     const user = await ctx.container.db.primary.query.users.findFirst({
+*       where: eq(users.id, ctx.input.userId),
+*     });
+*
+*     await ctx.container.mailer.send({
+*       to: ctx.input.email,
+*       subject: "Welcome!",
+*     });
+*
+*     return { sent: true };
+*   },
+* });
+*
+* // Triggering from a route:
+* import sendWelcomeEmail from "#api/workflows/send-welcome-email.ts";
+* const handle = await sendWelcomeEmail.start({ userId: "123", email: "..." });
+* ```
+*/
+function defineWorkflow(options) {
+	let container = null;
+	let workflowName = null;
+	let dbosInstance = null;
+	let registeredFn = null;
+	const workflowFn = async (input) => {
+		if (!container || !dbosInstance) throw new Error(`Workflow "${workflowName}" not registered`);
+		const dbos = dbosInstance;
+		const workflowId = dbos.workflowID;
+		if (!workflowId) throw new Error("DBOS.workflowID is not available in this context");
+		const ctx = {
+			container,
+			workflowId,
+			input,
+			step: (name, fn) => dbos.runStep(fn, { name })
+		};
+		return options.run(ctx);
+	};
+	return {
+		inputSchema: options.input,
+		get name() {
+			return workflowName;
+		},
+		register(c, name, dbos) {
+			container = c;
+			workflowName = name;
+			dbosInstance = dbos;
+			registeredFn = dbos.registerWorkflow(workflowFn, {
+				name,
+				...options.config
+			});
+		},
+		async start(input) {
+			if (!registeredFn || !workflowName || !dbosInstance) throw new Error("Workflow not registered. Ensure the worker is started before triggering workflows.");
+			const validated = options.input.parse(input);
+			const handle = await dbosInstance.startWorkflow(registeredFn)(validated);
+			return {
+				workflowId: handle.workflowID,
+				getStatus: () => handle.getStatus(),
+				getResult: () => handle.getResult()
+			};
+		}
+	};
+}
+/**
+* Defines a scheduled workflow that runs on a cron schedule.
+*
+* @example
+* ```typescript
+* // api/workflows/daily-report.ts
+* export default defineScheduledWorkflow({
+*   crontab: "0 9 * * *", // 9am daily
+*   async run(ctx) {
+*     const stats = await ctx.container.db.primary.query.stats.findMany();
+*     await ctx.container.mailer.send({
+*       to: "team@company.com",
+*       subject: `Daily Report - ${ctx.scheduledTime.toDateString()}`,
+*     });
+*   },
+* });
+* ```
+*/
+function defineScheduledWorkflow(options) {
+	let container = null;
+	let workflowName = null;
+	let dbosInstance = null;
+	const workflowFn = async (scheduledTime, _startTime) => {
+		if (!container || !dbosInstance) throw new Error(`Workflow "${workflowName}" not registered`);
+		const dbos = dbosInstance;
+		const workflowId = dbos.workflowID;
+		if (!workflowId) throw new Error("DBOS.workflowID is not available in this context");
+		const ctx = {
+			container,
+			workflowId,
+			scheduledTime,
+			step: (name, fn) => dbos.runStep(fn, { name })
+		};
+		return options.run(ctx);
+	};
+	return {
+		crontab: options.crontab,
+		get name() {
+			return workflowName;
+		},
+		register(c, name, dbos) {
+			container = c;
+			workflowName = name;
+			dbosInstance = dbos;
+			dbos.registerScheduled(dbos.registerWorkflow(workflowFn, { name }), { crontab: options.crontab });
+		}
+	};
+}
+
+//#endregion
+export { defineScheduledWorkflow, defineWorkflow };

package/dist/exports/api/workflows/constants.mjs

@@ -1 +1,23 @@
-process.env.NODE_ENV;export{};
+//#region src/constants.ts
+/**
+* Directory for public static assets.
+*
+* Expected structure:
+* - `<project-root>/public/` - Public directory root
+* - `<project-root>/public/locales/` - i18n translation files
+*
+* @default "public"
+*/
+const PUBLIC_DIR = process.env.NODE_ENV === "production" ? "client" : "public";
+/**
+* File extension for code files based on environment.
+*
+* In development: `.ts` (TypeScript source files)
+* In production: `.js` (bundled JavaScript files)
+*
+* @default "ts" in development, "js" in production
+*/
+const FILE_EXT = process.env.NODE_ENV === "production" ? "js" : "ts";
+
+//#endregion
+export {  };

package/dist/exports/api/workflows/extract-blob-metadata.mjs

@@ -1 +1,132 @@
-import{defineWorkflow as e}from"../workflow.mjs";import t from"zod";import{join as n}from"node:path";import{ALL_FORMATS as r,BlobSource as i,Input as a}from"mediabunny";const o=e({input:t.object({blobId:t.string()}),async run({container:e,input:{blobId:t},step:o}){let s=await o(`fetch-blob`,async()=>e.storage.primary.getBlob(t));if(!s)throw Error(`Blob ${t} not found`);let c=await o(`download-blob`,async()=>e.storage.primary.downloadBlob(t));if(!c)throw Error(`Failed to download blob ${t}`);let l={};return s.contentType?.startsWith(`image/`)?l=await o(`extract-image-metadata`,async()=>{let e=(await import(`sharp`)).default,t=await e(c).metadata();return{width:t.width,height:t.height,format:t.format,hasAlpha:t.hasAlpha,space:t.space}}):s.contentType?.startsWith(`video/`)||s.contentType?.startsWith(`audio/`)?l=await o(`extract-media-metadata`,async()=>{let e=new Uint8Array(c),t=new a({source:new i(new Blob([e],{type:s.contentType||`video/mp4`})),formats:r}),n=await t.computeDuration(),o=await t.getMetadataTags(),l={},u={},d=!1,f=!1;try{let e=await t.getPrimaryVideoTrack();if(e){d=!0;let t=e.displayWidth&&e.displayHeight?e.displayWidth/e.displayHeight:null;l={width:e.displayWidth,height:e.displayHeight,rotation:e.rotation,angle:e.rotation,displayAspectRatio:t}}}catch{}try{let e=await t.getPrimaryAudioTrack();e&&(f=!0,u={sampleRate:e.sampleRate,channels:e.numberOfChannels})}catch{}return{duration:n,video:d,audio:f,...l,...u,tags:o}}):s.contentType===`application/pdf`&&(l=await o(`extract-pdf-metadata`,async()=>{try{let e=await import(`pdfjs-dist/legacy/build/pdf.mjs`),t=`${n(process.cwd(),`node_modules/pdfjs-dist/standard_fonts`)}/`,r=await e.getDocument({data:new Uint8Array(c),standardFontDataUrl:t}).promise,i=await r.getMetadata(),a=(await r.getPage(1)).getViewport({scale:1}),o=i.info;return{pageCount:r.numPages,width:a.width,height:a.height,title:o?.Title||null,author:o?.Author||null,subject:o?.Subject||null,keywords:o?.Keywords||null,creator:o?.Creator||null,producer:o?.Producer||null,creationDate:o?.CreationDate||null,modificationDate:o?.ModDate||null,pdfVersion:o?.PDFFormatVersion||null}}catch(n){return e.logger.error({error:n,errorMessage:n instanceof Error?n.message:String(n),errorStack:n instanceof Error?n.stack:void 0,errorCode:n?.code,blobId:t},`Failed to extract PDF metadata`),{error:`Failed to extract PDF metadata`,errorMessage:n instanceof Error?n.message:String(n)}}})),await o(`save-metadata`,async()=>{await e.storage.primary.updateBlobMetadata(t,{...l,analyzed:!0})}),e.logger.info({blobId:t,metadata:l},`Metadata extracted`),{...l,analyzed:!0}}});export{o as extractBlobMetadata};
+import { defineWorkflow } from "./api/workflow.mjs";
+import z$1 from "zod";
+import { join } from "node:path";
+import { ALL_FORMATS, BlobSource, Input } from "mediabunny";
+
+//#region src/api/workflows/extract-blob-metadata.ts
+const extractBlobMetadata = defineWorkflow({
+	input: z$1.object({ blobId: z$1.string() }),
+	async run({ container, input: { blobId }, step }) {
+		const blob = await step("fetch-blob", async () => {
+			return container.storage.primary.getBlob(blobId);
+		});
+		if (!blob) throw new Error(`Blob ${blobId} not found`);
+		const buffer = await step("download-blob", async () => {
+			return container.storage.primary.downloadBlob(blobId);
+		});
+		if (!buffer) throw new Error(`Failed to download blob ${blobId}`);
+		let metadata = {};
+		if (blob.contentType?.startsWith("image/")) metadata = await step("extract-image-metadata", async () => {
+			const sharp = (await import("sharp")).default;
+			const info = await sharp(buffer).metadata();
+			return {
+				width: info.width,
+				height: info.height,
+				format: info.format,
+				hasAlpha: info.hasAlpha,
+				space: info.space
+			};
+		});
+		else if (blob.contentType?.startsWith("video/") || blob.contentType?.startsWith("audio/")) metadata = await step("extract-media-metadata", async () => {
+			const uint8Array = new Uint8Array(buffer);
+			const input = new Input({
+				source: new BlobSource(new Blob([uint8Array], { type: blob.contentType || "video/mp4" })),
+				formats: ALL_FORMATS
+			});
+			const duration = await input.computeDuration();
+			const tags = await input.getMetadataTags();
+			let videoData = {};
+			let audioData = {};
+			let hasVideo = false;
+			let hasAudio = false;
+			try {
+				const videoTrack = await input.getPrimaryVideoTrack();
+				if (videoTrack) {
+					hasVideo = true;
+					const displayAspectRatio = videoTrack.displayWidth && videoTrack.displayHeight ? videoTrack.displayWidth / videoTrack.displayHeight : null;
+					videoData = {
+						width: videoTrack.displayWidth,
+						height: videoTrack.displayHeight,
+						rotation: videoTrack.rotation,
+						angle: videoTrack.rotation,
+						displayAspectRatio
+					};
+				}
+			} catch {}
+			try {
+				const audioTrack = await input.getPrimaryAudioTrack();
+				if (audioTrack) {
+					hasAudio = true;
+					audioData = {
+						sampleRate: audioTrack.sampleRate,
+						channels: audioTrack.numberOfChannels
+					};
+				}
+			} catch {}
+			return {
+				duration,
+				video: hasVideo,
+				audio: hasAudio,
+				...videoData,
+				...audioData,
+				tags
+			};
+		});
+		else if (blob.contentType === "application/pdf") metadata = await step("extract-pdf-metadata", async () => {
+			try {
+				const pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs");
+				const standardFontDataUrl = `${join(process.cwd(), "node_modules/pdfjs-dist/standard_fonts")}/`;
+				const pdf = await pdfjsLib.getDocument({
+					data: new Uint8Array(buffer),
+					standardFontDataUrl
+				}).promise;
+				const pdfMetadata = await pdf.getMetadata();
+				const viewport = (await pdf.getPage(1)).getViewport({ scale: 1 });
+				const info = pdfMetadata.info;
+				return {
+					pageCount: pdf.numPages,
+					width: viewport.width,
+					height: viewport.height,
+					title: info?.Title || null,
+					author: info?.Author || null,
+					subject: info?.Subject || null,
+					keywords: info?.Keywords || null,
+					creator: info?.Creator || null,
+					producer: info?.Producer || null,
+					creationDate: info?.CreationDate || null,
+					modificationDate: info?.ModDate || null,
+					pdfVersion: info?.PDFFormatVersion || null
+				};
+			} catch (error) {
+				container.logger.error({
+					error,
+					errorMessage: error instanceof Error ? error.message : String(error),
+					errorStack: error instanceof Error ? error.stack : void 0,
+					errorCode: error?.code,
+					blobId
+				}, "Failed to extract PDF metadata");
+				return {
+					error: "Failed to extract PDF metadata",
+					errorMessage: error instanceof Error ? error.message : String(error)
+				};
+			}
+		});
+		await step("save-metadata", async () => {
+			await container.storage.primary.updateBlobMetadata(blobId, {
+				...metadata,
+				analyzed: true
+			});
+		});
+		container.logger.info({
+			blobId,
+			metadata
+		}, "Metadata extracted");
+		return {
+			...metadata,
+			analyzed: true
+		};
+	}
+});
+
+//#endregion
+export { extractBlobMetadata };

package/dist/exports/api/workflows/generate-image-variant.d.mts

@@ -1,5 +1,5 @@
-import "../workflow.mjs";
-import "../index.mjs";
+import "./api/workflow.mjs";
+import "./api/container.mjs";
 import { z } from "zod";
 
 //#region src/api/workflows/generate-image-variant.d.ts

package/dist/exports/api/workflows/generate-image-variant.mjs

@@ -1 +1,118 @@
-import{defineWorkflow as e}from"../workflow.mjs";import{z as t}from"zod";const n=t.object({width:t.number().optional(),height:t.number().optional(),fit:t.enum([`cover`,`contain`,`fill`,`inside`,`outside`]).optional(),position:t.enum([`top`,`right top`,`right`,`right bottom`,`bottom`,`left bottom`,`left`,`left top`,`centre`]).optional(),kernel:t.enum([`nearest`,`linear`,`cubic`,`mitchell`,`lanczos2`,`lanczos3`]).optional()}),r=t.object({resize:n.optional(),rotate:t.number().optional(),flip:t.boolean().optional(),flop:t.boolean().optional(),sharpen:t.boolean().optional(),blur:t.number().optional(),grayscale:t.boolean().optional(),format:t.enum([`jpeg`,`png`,`webp`,`avif`,`gif`]).optional(),quality:t.number().min(1).max(100).optional(),preview:t.literal(!0).optional()}),i=e({input:t.object({blobId:t.string(),transformations:r}),async run({container:e,input:{blobId:t,transformations:n},step:r}){if(!await r(`fetch-blob`,async()=>e.storage.primary.getBlob(t)))throw Error(`Blob ${t} not found`);let i=await r(`download-blob`,async()=>e.storage.primary.downloadBlob(t));if(!i)throw Error(`Failed to download blob ${t}`);let a=await r(`apply-transformations`,async()=>{let e=(await import(`sharp`)).default,t=e(i);return n.resize&&(t=t.resize({width:n.resize.width,height:n.resize.height,fit:n.resize.fit,position:n.resize.position,kernel:n.resize.kernel})),n.rotate!==void 0&&(t=t.rotate(n.rotate)),n.flip&&(t=t.flip()),n.flop&&(t=t.flop()),n.sharpen&&(t=t.sharpen()),n.blur!==void 0&&(t=t.blur(n.blur)),n.grayscale&&(t=t.grayscale()),n.format&&(t=t.toFormat(n.format,{quality:n.quality})),t.toBuffer()}),o=await r(`store-variant`,async()=>e.storage.primary.createVariant(t,n,a));return e.logger.info({blobId:t,variantId:o.id},`Image variant generated`),o}});export{i as generateImageVariant};
+import { defineWorkflow } from "./api/workflow.mjs";
+import { z } from "zod";
+
+//#region src/api/workflows/generate-image-variant.ts
+/**
+* Resize options schema for image transformations.
+*/
+const resizeSchema = z.object({
+	width: z.number().optional(),
+	height: z.number().optional(),
+	fit: z.enum([
+		"cover",
+		"contain",
+		"fill",
+		"inside",
+		"outside"
+	]).optional(),
+	position: z.enum([
+		"top",
+		"right top",
+		"right",
+		"right bottom",
+		"bottom",
+		"left bottom",
+		"left",
+		"left top",
+		"centre"
+	]).optional(),
+	kernel: z.enum([
+		"nearest",
+		"linear",
+		"cubic",
+		"mitchell",
+		"lanczos2",
+		"lanczos3"
+	]).optional()
+});
+/**
+* Image transformations schema.
+* Supports resize, rotate, flip, flop, sharpen, blur, grayscale, format conversion.
+*/
+const transformationsSchema = z.object({
+	resize: resizeSchema.optional(),
+	rotate: z.number().optional(),
+	flip: z.boolean().optional(),
+	flop: z.boolean().optional(),
+	sharpen: z.boolean().optional(),
+	blur: z.number().optional(),
+	grayscale: z.boolean().optional(),
+	format: z.enum([
+		"jpeg",
+		"png",
+		"webp",
+		"avif",
+		"gif"
+	]).optional(),
+	quality: z.number().min(1).max(100).optional(),
+	preview: z.literal(true).optional()
+});
+/**
+* Generate image variant workflow. Applies transformations to create variants.
+*
+* Algorithm:
+* 1. Fetch blob by ID
+* 2. Download blob content
+* 3. Apply transformations using Sharp:
+*    - Resize with various fit options
+*    - Rotate by degrees
+*    - Flip/flop (vertical/horizontal mirror)
+*    - Sharpen, blur, grayscale filters
+*    - Format conversion with quality settings
+* 4. Store variant with transformation metadata
+*/
+const generateImageVariant = defineWorkflow({
+	input: z.object({
+		blobId: z.string(),
+		transformations: transformationsSchema
+	}),
+	async run({ container, input: { blobId, transformations }, step }) {
+		if (!await step("fetch-blob", async () => {
+			return container.storage.primary.getBlob(blobId);
+		})) throw new Error(`Blob ${blobId} not found`);
+		const buffer = await step("download-blob", async () => {
+			return container.storage.primary.downloadBlob(blobId);
+		});
+		if (!buffer) throw new Error(`Failed to download blob ${blobId}`);
+		const variantBuffer = await step("apply-transformations", async () => {
+			const sharp = (await import("sharp")).default;
+			let pipeline = sharp(buffer);
+			if (transformations.resize) pipeline = pipeline.resize({
+				width: transformations.resize.width,
+				height: transformations.resize.height,
+				fit: transformations.resize.fit,
+				position: transformations.resize.position,
+				kernel: transformations.resize.kernel
+			});
+			if (transformations.rotate !== void 0) pipeline = pipeline.rotate(transformations.rotate);
+			if (transformations.flip) pipeline = pipeline.flip();
+			if (transformations.flop) pipeline = pipeline.flop();
+			if (transformations.sharpen) pipeline = pipeline.sharpen();
+			if (transformations.blur !== void 0) pipeline = pipeline.blur(transformations.blur);
+			if (transformations.grayscale) pipeline = pipeline.grayscale();
+			if (transformations.format) pipeline = pipeline.toFormat(transformations.format, { quality: transformations.quality });
+			return pipeline.toBuffer();
+		});
+		const variant = await step("store-variant", async () => {
+			return container.storage.primary.createVariant(blobId, transformations, variantBuffer);
+		});
+		container.logger.info({
+			blobId,
+			variantId: variant.id
+		}, "Image variant generated");
+		return variant;
+	}
+});
+
+//#endregion
+export { generateImageVariant };