@m5kdev/backend 0.1.0 → 0.1.2

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

@@ -0,0 +1,89 @@
+import type { User } from "#modules/auth/auth.lib";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { ConnectDeleteInputSchema, ConnectListInputSchema } from "#modules/connect/connect.dto";
+import type { ConnectRepository } from "./connect.repository";
+import type { ConnectProvider } from "./connect.types";
+export declare class ConnectService extends BaseService<{
+    connect: ConnectRepository;
+}, never> {
+    private providers;
+    constructor(repositories: {
+        connect: ConnectRepository;
+    }, providers: ConnectProvider[]);
+    getProvider(id: string): ConnectProvider | null;
+    startAuth(_user: User, sessionId: string, providerId: string): ServerResultAsync<{
+        url: string;
+    }>;
+    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;
+        tokenType: string | null;
+        metadataJson: unknown;
+        revokedAt: Date | null;
+        lastRefreshedAt: 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;
+        tokenType: string | null;
+        metadataJson: unknown;
+        revokedAt: Date | null;
+        lastRefreshedAt: Date | null;
+    }>>;
+    list(input: ConnectListInputSchema, { user }: {
+        user: User;
+    }): Promise<import("#modules/base/base.dto").ServerResult<{
+        id: string;
+        userId: string;
+        provider: string;
+        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;
+    }[]>>;
+    delete({ id }: ConnectDeleteInputSchema, { user }: {
+        user: User;
+    }): Promise<import("#modules/base/base.dto").ServerResult<{
+        id: string;
+    }>>;
+}
+//# sourceMappingURL=connect.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,8BAA8B,CAAC;AAQtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,qBAAa,cAAe,SAAQ,WAAW,CAAC;IAAE,OAAO,EAAE,iBAAiB,CAAA;CAAE,EAAE,KAAK,CAAC;IACpF,OAAO,CAAC,SAAS,CAAsC;gBAE3C,YAAY,EAAE;QAAE,OAAO,EAAE,iBAAiB,CAAA;KAAE,EAAE,SAAS,EAAE,eAAe,EAAE;IAKtF,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAIzC,SAAS,CACb,KAAK,EAAE,IAAI,EACX,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,iBAAiB,CAAC;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IAc/B,cAAc,CAClB,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;IAsDT,YAAY,CAAC,YAAY,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;IAiDjC,IAAI,CAAC,KAAK,EAAE,sBAAsB,EAAE,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;IAI5D,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,wBAAwB,EAAE,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE;;;CAUxE"}

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

@@ -0,0 +1,81 @@
+import type { ConnectService } from "./connect.service";
+export declare function createConnectTRPC(connectService: ConnectService): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        session: {
+            id: string;
+            userId: string;
+            updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
+            token: string;
+            ipAddress: string | null;
+            userAgent: string | null;
+            impersonatedBy: string | null;
+            activeOrganizationId: string | null;
+            activeOrganizationRole: string | null;
+            activeTeamId: string | null;
+            activeTeamRole: string | null;
+        };
+        user: {
+            name: string;
+            id: string;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
+            role: string | null;
+            banned: boolean | null;
+            banReason: string | null;
+            banExpires: Date | null;
+            stripeCustomerId: string | null;
+            paymentCustomerId: string | null;
+            paymentPlanTier: string | null;
+            paymentPlanExpiresAt: Date | null;
+            preferences: string | null;
+            metadata: Record<string, unknown>;
+            onboarding: number | null;
+            flags: string | null;
+        };
+    };
+    meta: import("trpc-to-openapi").OpenApiMeta;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            providers?: string[] | undefined;
+            inactive?: boolean | undefined;
+        };
+        output: {
+            id: string;
+            userId: string;
+            createdAt: Date;
+            provider: string;
+            accountType: string;
+            providerAccountId: string;
+            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;
+            metadataJson?: unknown;
+            revokedAt?: Date | null | undefined;
+            lastRefreshedAt?: Date | null | undefined;
+        }[];
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            id: string;
+        };
+        meta: import("trpc-to-openapi").OpenApiMeta;
+    }>;
+}>>;
+//# sourceMappingURL=connect.trpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.trpc.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.trpc.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgB/D"}

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.d.ts

@@ -0,0 +1,26 @@
+export interface ConnectProvider {
+    id: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    scopes: string[];
+    issuerConfig?: {
+        issuer: string;
+        authorization_endpoint: string;
+        token_endpoint: string;
+        userinfo_endpoint?: string;
+    };
+    issuerUrl?: string;
+    supportsPKCE?: boolean;
+    mapProfile: (accessToken: string) => Promise<ConnectProfile>;
+}
+export interface ConnectProfile {
+    providerAccountId: string;
+    displayName?: string;
+    avatarUrl?: string;
+    handle?: string;
+    accountType: "user" | "page" | "org" | "channel";
+    parentId?: string;
+    metadata?: Record<string, unknown>;
+}
+//# sourceMappingURL=connect.types.d.ts.map

package/dist/src/modules/connect/connect.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.types.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE;QACb,MAAM,EAAE,MAAM,CAAC;QACf,sBAAsB,EAAE,MAAM,CAAC;QAC/B,cAAc,EAAE,MAAM,CAAC;QACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,cAAc;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC"}

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.d.ts

@@ -0,0 +1,152 @@
+export declare const cryptoPayments: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "crypto_payments";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "crypto_payments";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "crypto_payments";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "crypto_payments";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        address: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "address";
+            tableName: "crypto_payments";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        referenceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "reference_id";
+            tableName: "crypto_payments";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "crypto_payments";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        derivationIndex: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "derivation_index";
+            tableName: "crypto_payments";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        amountExpected: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "amount_expected";
+            tableName: "crypto_payments";
+            dataType: "number";
+            columnType: "SQLiteReal";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=crypto.db.d.ts.map

package/dist/src/modules/crypto/crypto.db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.db.d.ts","sourceRoot":"","sources":["../../../../src/modules/crypto/crypto.db.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC"}

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(),
+});