@m5kdev/backend 0.1.1 → 0.1.3

package/dist/src/modules/connect/connect.repository.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectRepository = void 0;
+const tslib_1 = require("tslib");
+const drizzle_orm_1 = require("drizzle-orm");
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+const connect = tslib_1.__importStar(require("#modules/connect/connect.db"));
+const schema = { ...connect };
+class ConnectRepository extends base_repository_1.BaseTableRepository {
+    async list(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const { ConditionBuilder } = this.helpers;
+            const conditions = new ConditionBuilder();
+            if (data.providers)
+                conditions.push((0, drizzle_orm_1.inArray)(this.schema.connect.provider, data.providers));
+            if (data.inactive)
+                conditions.push((0, drizzle_orm_1.isNull)(this.schema.connect.revokedAt));
+            conditions.push((0, drizzle_orm_1.eq)(this.schema.connect.userId, data.userId));
+            const rows = await db.select().from(this.schema.connect).where(conditions.join());
+            return (0, neverthrow_1.ok)(rows);
+        });
+    }
+    async upsert(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const [existing] = await db
+                .select()
+                .from(this.schema.connect)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.connect.userId, data.userId), (0, drizzle_orm_1.eq)(this.schema.connect.provider, data.provider), (0, drizzle_orm_1.eq)(this.schema.connect.providerAccountId, data.providerAccountId)))
+                .limit(1);
+            if (existing) {
+                // Update existing
+                const [updated] = await db
+                    .update(this.schema.connect)
+                    .set({
+                    ...data,
+                    updatedAt: new Date(),
+                    lastRefreshedAt: new Date(),
+                })
+                    .where((0, drizzle_orm_1.eq)(this.schema.connect.id, existing.id))
+                    .returning();
+                return (0, neverthrow_1.ok)(updated);
+            }
+            // Create new
+            const [created] = await db.insert(this.schema.connect).values(data).returning();
+            if (!created)
+                return this.error("UNPROCESSABLE_CONTENT");
+            return (0, neverthrow_1.ok)(created);
+        });
+    }
+}
+exports.ConnectRepository = ConnectRepository;

package/dist/src/modules/connect/connect.router.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnectRouter = createConnectRouter;
+const express_1 = require("express");
+function createConnectRouter(authMiddleware, connectService) {
+    const connectRouter = (0, express_1.Router)();
+    connectRouter.get("/:provider/start", authMiddleware, async (req, res) => {
+        const user = req.user;
+        const session = req.session;
+        if (!user || !session) {
+            return res.status(401).json({ message: "Unauthorized" });
+        }
+        const { provider } = req.params;
+        const { redirect } = req.query;
+        const result = await connectService.startAuth(user, session.id, provider);
+        if (result.isErr()) {
+            const errorUrl = redirect
+                ? `${redirect}?error=${encodeURIComponent(result.error.message)}`
+                : `${process.env.VITE_APP_URL || process.env.VITE_SERVER_URL || "/"}?connect_error=${encodeURIComponent(result.error.message)}`;
+            return res.redirect(errorUrl);
+        }
+        return res.redirect(result.value.url);
+    });
+    connectRouter.get("/:provider/callback", authMiddleware, async (req, res) => {
+        const user = req.user;
+        const session = req.session;
+        if (!user || !session) {
+            return res.status(401).json({ message: "Unauthorized" });
+        }
+        const { provider } = req.params;
+        const { code, state, error, error_description } = req.query;
+        const { redirect } = req.query;
+        const successUrl = redirect && typeof redirect === "string"
+            ? redirect
+            : `${process.env.VITE_APP_URL || process.env.VITE_SERVER_URL || "/"}?connect_success=true`;
+        // Handle OAuth errors from provider
+        if (error) {
+            const errorMessage = error_description || error || "OAuth error";
+            const errorUrl = `${successUrl}&error=${encodeURIComponent(String(errorMessage))}`;
+            return res.redirect(errorUrl);
+        }
+        if (!code || !state) {
+            const errorUrl = `${successUrl}&error=${encodeURIComponent("Missing code or state")}`;
+            return res.redirect(errorUrl);
+        }
+        const result = await connectService.handleCallback(user, session.id, provider, String(code), String(state));
+        if (result.isErr()) {
+            const errorUrl = `${successUrl}&error=${encodeURIComponent(result.error.message)}`;
+            return res.redirect(errorUrl);
+        }
+        return res.redirect(`${successUrl}&provider=${provider}`);
+    });
+    return connectRouter;
+}

package/dist/src/modules/connect/connect.service.d.ts

@@ -18,44 +18,44 @@ export declare class ConnectService extends BaseService<{
     handleCallback(user: User, sessionId: string, providerId: string, code: string, state: string): Promise<import("#modules/base/base.dto").ServerResult<{
         id: string;
         userId: string;
+        updatedAt: Date | null;
+        createdAt: Date;
+        expiresAt: Date | null;
+        accessToken: string;
+        refreshToken: string | null;
+        scope: string | null;
         provider: string;
+        parentId: string | null;
         accountType: string;
         providerAccountId: string;
         handle: string | null;
         displayName: string | null;
         avatarUrl: string | null;
-        accessToken: string;
-        refreshToken: string | null;
         tokenType: string | null;
-        scope: string | null;
-        expiresAt: Date | null;
-        parentId: string | null;
         metadataJson: unknown;
         revokedAt: Date | null;
         lastRefreshedAt: Date | null;
-        createdAt: Date;
-        updatedAt: Date | null;
     }>>;
     refreshToken(connectionId: string): Promise<import("#modules/base/base.dto").ServerResult<{
         id: string;
         userId: string;
+        updatedAt: Date | null;
+        createdAt: Date;
+        expiresAt: Date | null;
+        accessToken: string;
+        refreshToken: string | null;
+        scope: string | null;
         provider: string;
+        parentId: string | null;
         accountType: string;
         providerAccountId: string;
         handle: string | null;
         displayName: string | null;
         avatarUrl: string | null;
-        accessToken: string;
-        refreshToken: string | null;
         tokenType: string | null;
-        scope: string | null;
-        expiresAt: Date | null;
-        parentId: string | null;
         metadataJson: unknown;
         revokedAt: Date | null;
         lastRefreshedAt: Date | null;
-        createdAt: Date;
-        updatedAt: Date | null;
     }>>;
     list(input: ConnectListInputSchema, { user }: {
         user: User;

package/dist/src/modules/connect/connect.service.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectService = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+const connect_oauth_1 = require("./connect.oauth");
+class ConnectService extends base_service_1.BaseService {
+    providers = new Map();
+    constructor(repositories, providers) {
+        super(repositories);
+        this.providers = new Map(providers.map((provider) => [provider.id, provider]));
+    }
+    getProvider(id) {
+        return this.providers.get(id) || null;
+    }
+    async startAuth(_user, sessionId, providerId) {
+        return this.throwableAsync(async () => {
+            const provider = this.getProvider(providerId);
+            if (!provider) {
+                return this.error("BAD_REQUEST", `Unknown provider: ${providerId}`);
+            }
+            const state = await (0, connect_oauth_1.generateOAuthState)(sessionId, providerId);
+            const url = await (0, connect_oauth_1.buildAuthorizationUrl)(provider, state);
+            return (0, neverthrow_1.ok)({ url });
+        });
+    }
+    async handleCallback(user, sessionId, providerId, code, state) {
+        return this.throwableAsync(async () => {
+            const provider = this.getProvider(providerId);
+            if (!provider) {
+                return this.error("BAD_REQUEST", `Unknown provider: ${providerId}`);
+            }
+            const oauthState = (0, connect_oauth_1.getOAuthState)(sessionId, providerId, state);
+            if (!oauthState) {
+                return this.error("BAD_REQUEST", "Invalid or expired state");
+            }
+            // Exchange code for tokens
+            // Note: redirectUri must match exactly what was used in authorization request
+            const tokens = await (0, connect_oauth_1.exchangeCodeForTokens)(provider, code, oauthState.codeVerifier, provider.redirectUri, state);
+            // Fetch profile
+            const profile = await provider.mapProfile(tokens.accessToken);
+            // Upsert connection
+            const connection = await this.repository.connect.upsert({
+                userId: user.id,
+                provider: providerId,
+                accountType: profile.accountType,
+                providerAccountId: profile.providerAccountId,
+                handle: profile.handle,
+                displayName: profile.displayName,
+                avatarUrl: profile.avatarUrl,
+                accessToken: tokens.accessToken,
+                refreshToken: tokens.refreshToken,
+                tokenType: tokens.tokenType || "bearer",
+                scope: tokens.scope,
+                expiresAt: tokens.expiresAt,
+                parentId: profile.parentId,
+                metadataJson: profile.metadata ? JSON.stringify(profile.metadata) : null,
+            });
+            if (connection.isErr()) {
+                return this.error("INTERNAL_SERVER_ERROR", "Failed to save connection", {
+                    cause: connection.error,
+                });
+            }
+            return (0, neverthrow_1.ok)(connection.value);
+        });
+    }
+    async refreshToken(connectionId) {
+        return this.throwableAsync(async () => {
+            const connection = await this.repository.connect.findById(connectionId);
+            if (connection.isErr() || !connection.value) {
+                return this.error("NOT_FOUND", "Connection not found");
+            }
+            const conn = connection.value;
+            if (!conn.refreshToken) {
+                return this.error("BAD_REQUEST", "No refresh token available");
+            }
+            const provider = this.getProvider(conn.provider);
+            if (!provider) {
+                return this.error("BAD_REQUEST", `Unknown provider: ${conn.provider}`);
+            }
+            const tokens = await (0, connect_oauth_1.refreshAccessToken)(provider, conn.refreshToken);
+            const updateData = {
+                id: conn.id,
+                accessToken: tokens.accessToken,
+                refreshToken: tokens.refreshToken || null,
+                tokenType: tokens.tokenType || conn.tokenType || null,
+                scope: tokens.scope || conn.scope || null,
+                expiresAt: tokens.expiresAt || null,
+                lastRefreshedAt: new Date(),
+            };
+            const updated = await this.repository.connect.update(updateData);
+            if (updated.isErr()) {
+                return this.error("INTERNAL_SERVER_ERROR", "Failed to update tokens", {
+                    cause: updated.error,
+                });
+            }
+            return (0, neverthrow_1.ok)(updated.value);
+        });
+    }
+    async list(input, { user }) {
+        return this.repository.connect.list({ userId: user.id, ...input });
+    }
+    async delete({ id }, { user }) {
+        const connection = await this.repository.connect.findById(id);
+        if (connection.isOk()) {
+            if (connection.value?.userId !== user.id) {
+                return this.error("FORBIDDEN", "Not your connection");
+            }
+            return this.repository.connect.deleteById(id);
+        }
+        return (0, neverthrow_1.err)(connection.error);
+    }
+}
+exports.ConnectService = ConnectService;

package/dist/src/modules/connect/connect.trpc.d.ts

@@ -4,9 +4,9 @@ export declare function createConnectTRPC(connectService: ConnectService): impor
         session: {
             id: string;
             userId: string;
-            expiresAt: Date;
-            createdAt: Date;
             updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
             token: string;
             ipAddress: string | null;
             userAgent: string | null;
@@ -18,13 +18,12 @@ export declare function createConnectTRPC(connectService: ConnectService): impor
         };
         user: {
             name: string;
-            image: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date;
             email: string;
-            metadata: Record<string, unknown>;
             emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
             role: string | null;
             banned: boolean | null;
             banReason: string | null;
@@ -34,6 +33,7 @@ export declare function createConnectTRPC(connectService: ConnectService): impor
             paymentPlanTier: string | null;
             paymentPlanExpiresAt: Date | null;
             preferences: string | null;
+            metadata: Record<string, unknown>;
             onboarding: number | null;
             flags: string | null;
         };
@@ -50,21 +50,21 @@ export declare function createConnectTRPC(connectService: ConnectService): impor
         output: {
             id: string;
             userId: string;
+            createdAt: Date;
             provider: string;
             accountType: string;
             providerAccountId: string;
-            createdAt: Date;
+            updatedAt?: Date | null | undefined;
+            expiresAt?: Date | null | undefined;
+            scope?: string | null | undefined;
+            parentId?: string | null | undefined;
             handle?: string | null | undefined;
             displayName?: string | null | undefined;
             avatarUrl?: string | null | undefined;
             tokenType?: string | null | undefined;
-            scope?: string | null | undefined;
-            expiresAt?: Date | null | undefined;
-            parentId?: string | null | undefined;
             metadataJson?: unknown;
             revokedAt?: Date | null | undefined;
             lastRefreshedAt?: Date | null | undefined;
-            updatedAt?: Date | null | undefined;
         }[];
         meta: import("trpc-to-openapi").OpenApiMeta;
     }>;

package/dist/src/modules/connect/connect.trpc.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnectTRPC = createConnectTRPC;
+const _trpc_1 = require("#trpc");
+const connect_dto_1 = require("./connect.dto");
+function createConnectTRPC(connectService) {
+    return (0, _trpc_1.router)({
+        list: _trpc_1.procedure
+            .input(connect_dto_1.connectListInputSchema)
+            .output(connect_dto_1.connectListOutputSchema)
+            .query(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await connectService.list(input, ctx));
+        }),
+        delete: _trpc_1.procedure
+            .input(connect_dto_1.connectDeleteInputSchema)
+            .output(connect_dto_1.connectDeleteOutputSchema)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await connectService.delete(input, ctx));
+        }),
+    });
+}

package/dist/src/modules/connect/connect.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/modules/crypto/crypto.db.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cryptoPayments = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+exports.cryptoPayments = (0, sqlite_core_1.sqliteTable)("crypto_payments", {
+    id: (0, sqlite_core_1.text)("id").primaryKey().$default(uuid_1.v4),
+    createdAt: (0, sqlite_core_1.integer)("created_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+    updatedAt: (0, sqlite_core_1.integer)("updated_at", { mode: "timestamp" }),
+    address: (0, sqlite_core_1.text)("address").notNull(),
+    referenceId: (0, sqlite_core_1.text)("reference_id").notNull(),
+    status: (0, sqlite_core_1.text)("status").notNull().default("pending"),
+    derivationIndex: (0, sqlite_core_1.integer)("derivation_index").notNull(),
+    amountExpected: (0, sqlite_core_1.real)("amount_expected").notNull(),
+});

package/dist/src/modules/crypto/crypto.repository.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoRepository = void 0;
+const tslib_1 = require("tslib");
+const base_repository_1 = require("#modules/base/base.repository");
+const crypto = tslib_1.__importStar(require("#modules/crypto/crypto.db"));
+const schema = { ...crypto };
+class CryptoRepository extends base_repository_1.BaseTableRepository {
+}
+exports.CryptoRepository = CryptoRepository;

package/dist/src/modules/crypto/crypto.service.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoService = void 0;
+const tslib_1 = require("tslib");
+const bip32_1 = tslib_1.__importDefault(require("bip32"));
+const bip39 = tslib_1.__importStar(require("bip39"));
+const bitcoin = tslib_1.__importStar(require("bitcoinjs-lib"));
+const ecc = tslib_1.__importStar(require("tiny-secp256k1"));
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+const BITCOIN_NATIVE_SEGWIT_PATH = "m/84'/0'/0'/0";
+const bip32 = (0, bip32_1.default)(ecc);
+class CryptoService extends base_service_1.BaseService {
+    root = null;
+    getRoot() {
+        if (this.root)
+            return this.root;
+        const seed = process.env.BITCOIN_SEED;
+        if (!seed?.trim()) {
+            throw new Error("BITCOIN_SEED environment variable is not set");
+        }
+        if (!bip39.validateMnemonic(seed.trim())) {
+            throw new Error("BITCOIN_SEED is not a valid BIP39 mnemonic");
+        }
+        const seedBuffer = bip39.mnemonicToSeedSync(seed.trim());
+        this.root = bip32.fromSeed(seedBuffer);
+        return this.root;
+    }
+    createBitcoinAddress(derivationIndex) {
+        return this.throwable(() => {
+            if (derivationIndex < 0 || !Number.isInteger(derivationIndex)) {
+                return this.error("BAD_REQUEST", "derivationIndex must be a non-negative integer");
+            }
+            const root = this.getRoot();
+            const path = `${BITCOIN_NATIVE_SEGWIT_PATH}/${derivationIndex}`;
+            const child = root.derivePath(path);
+            if (!child.publicKey) {
+                return this.error("INTERNAL_SERVER_ERROR", "Failed to derive public key");
+            }
+            const payment = bitcoin.payments.p2wpkh({
+                pubkey: child.publicKey,
+                network: bitcoin.networks.bitcoin,
+            });
+            const address = payment.address;
+            if (!address) {
+                return this.error("INTERNAL_SERVER_ERROR", "Failed to generate address");
+            }
+            return (0, neverthrow_1.ok)(address);
+        });
+    }
+}
+exports.CryptoService = CryptoService;

package/dist/src/modules/email/email.service.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailService = void 0;
+const neverthrow_1 = require("neverthrow");
+const react_1 = require("react");
+const resend_1 = require("resend");
+const base_service_1 = require("#modules/base/base.service");
+class EmailService extends base_service_1.BaseService {
+    client;
+    brand;
+    noReplyFrom;
+    templates;
+    systemNotificationEmail;
+    constructor(props) {
+        super(undefined, undefined);
+        this.client = new resend_1.Resend(props.resendApiKey || process.env.RESEND_API_KEY);
+        this.client = {};
+        this.brand = props.brand;
+        this.noReplyFrom = props.noReplyFrom;
+        this.templates = props.templates;
+        this.systemNotificationEmail = props.systemNotificationEmail;
+    }
+    async sendTemplate(to, templateKey, templateProps, options) {
+        const template = this.templates[templateKey];
+        if (!template) {
+            return this.error("NOT_FOUND", `Email template not found: ${String(templateKey)}`);
+        }
+        const from = options?.from || this.noReplyFrom;
+        const subject = options?.subject || template.subject || String(templateKey);
+        const previewText = options?.previewText || template.previewText || subject;
+        const { error } = await this.client.emails.send({
+            to,
+            subject,
+            from,
+            react: (0, react_1.createElement)(template.react, { ...templateProps, previewText }),
+        });
+        if (error)
+            return this.error("INTERNAL_SERVER_ERROR", `Failed to send email: ${templateKey}`, {
+                cause: error,
+            });
+        return (0, neverthrow_1.ok)();
+    }
+    async sendBrandTemplate(to, templateKey, templateProps, options) {
+        return this.sendTemplate(to, templateKey, {
+            brand: this.brand,
+            ...templateProps,
+        }, options);
+    }
+    async sendWaitlistConfirmation(email, overrideOptions) {
+        return this.sendTemplate(email, "waitlistConfirmation", {
+            email,
+            brand: this.brand,
+        }, overrideOptions);
+    }
+    async sendWaitlistInvite(email, code, overrideOptions) {
+        const url = `${process.env.VITE_APP_URL}/signup?code=${code}&email=${email}`;
+        return this.sendTemplate(email, "waitlistInvite", {
+            url,
+            brand: this.brand,
+        }, overrideOptions);
+    }
+    async sendWaitlistUserInvite(email, code, inviter, name, overrideOptions) {
+        const url = `${process.env.VITE_APP_URL}/signup?code=${code}&email=${email}`;
+        return this.sendTemplate(email, "waitlistUserInvite", {
+            url,
+            brand: this.brand,
+            inviter,
+            name,
+        }, {
+            previewText: `Create your ${this.brand.name} account today!`,
+            subject: `${inviter} has invited you to join ${this.brand.name}!`,
+            ...overrideOptions,
+        });
+    }
+    async sendOrganizationInvite(email, organizationName, inviterName, role, url, overrideOptions) {
+        return this.sendTemplate(email, "organizationInvite", {
+            url,
+            brand: this.brand,
+            organizationName,
+            inviterName,
+            role,
+        }, {
+            previewText: `${inviterName} invited you to ${organizationName}`,
+            subject: `${inviterName} invited you to join ${organizationName}`,
+            ...overrideOptions,
+        });
+    }
+    async sendVerification(email, url, overrideOptions) {
+        return this.sendTemplate(email, "verification", {
+            url,
+            brand: this.brand,
+        }, overrideOptions);
+    }
+    async sendResetPassword(email, url, overrideOptions) {
+        return this.sendTemplate(email, "passwordReset", {
+            url,
+            brand: this.brand,
+        }, overrideOptions);
+    }
+    async sendDeleteAccountVerification(email, url, overrideOptions) {
+        return this.sendTemplate(email, "accountDeletion", {
+            url,
+            brand: this.brand,
+        }, overrideOptions);
+    }
+}
+exports.EmailService = EmailService;

package/dist/src/modules/file/file.repository.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRepository = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+class FileRepository extends base_repository_1.BaseExternaRepository {
+    s3;
+    constructor() {
+        super();
+        if (!process.env.AWS_REGION ||
+            !process.env.AWS_ACCESS_KEY_ID ||
+            !process.env.AWS_SECRET_ACCESS_KEY) {
+            throw new Error("Missing AWS environment variables");
+        }
+        this.s3 = new client_s3_1.S3Client({
+            region: process.env.AWS_REGION,
+            credentials: {
+                accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+                secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+            },
+            ...(process.env.AWS_S3_ENDPOINT ? { endpoint: process.env.AWS_S3_ENDPOINT } : {}),
+            forcePathStyle: !!process.env.AWS_S3_ENDPOINT, // Path style is often required for non-AWS S3 providers
+        });
+    }
+    async getS3UploadUrl(filename, filetype, expiresIn = 60 * 5) {
+        return this.throwableAsync(async () => {
+            const command = new client_s3_1.PutObjectCommand({
+                Bucket: process.env.AWS_S3_BUCKET,
+                Key: filename,
+                ContentType: filetype,
+            });
+            const url = await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn });
+            return (0, neverthrow_1.ok)(url);
+        });
+    }
+    async getS3DownloadUrl(path, expiresIn = 60 * 5) {
+        return this.throwableAsync(async () => {
+            const command = new client_s3_1.GetObjectCommand({
+                Bucket: process.env.AWS_S3_BUCKET,
+                Key: path,
+            });
+            const url = await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn });
+            return (0, neverthrow_1.ok)(url);
+        });
+    }
+    async getS3Object(path) {
+        return this.throwableAsync(async () => {
+            const command = new client_s3_1.GetObjectCommand({
+                Bucket: process.env.AWS_S3_BUCKET,
+                Key: path,
+            });
+            const data = await this.s3.send(command);
+            return (0, neverthrow_1.ok)(data);
+        });
+    }
+    async getS3ObjectT(path) {
+        return this.throwableAsync(async () => {
+            const command = new client_s3_1.GetObjectCommand({
+                Bucket: process.env.AWS_S3_BUCKET,
+                Key: path,
+            });
+            const data = await this.s3.send(command);
+            return (0, neverthrow_1.ok)(data);
+        });
+    }
+    async deleteS3Object(path) {
+        return this.throwableAsync(async () => {
+            const command = new client_s3_1.DeleteObjectCommand({
+                Bucket: process.env.AWS_S3_BUCKET,
+                Key: path,
+            });
+            await this.s3.send(command);
+            return (0, neverthrow_1.ok)(undefined);
+        });
+    }
+}
+exports.FileRepository = FileRepository;