@m5kdev/backend 0.1.0 → 0.1.2

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

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOAuthState = generateOAuthState;
+exports.getOAuthState = getOAuthState;
+exports.createConfiguration = createConfiguration;
+exports.buildAuthorizationUrl = buildAuthorizationUrl;
+exports.exchangeCodeForTokens = exchangeCodeForTokens;
+exports.refreshAccessToken = refreshAccessToken;
+const tslib_1 = require("tslib");
+const client = tslib_1.__importStar(require("openid-client"));
+const logger_1 = require("#utils/logger");
+// In-memory store for OAuth state (keyed by sessionId + provider)
+// In production, consider using Redis with TTL
+const oauthStateStore = new Map();
+const STATE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+function getStateKey(sessionId, provider) {
+    return `${sessionId}:${provider}`;
+}
+async function generateOAuthState(sessionId, provider) {
+    const state = client.randomState();
+    const codeVerifier = client.randomPKCECodeVerifier();
+    const codeChallenge = await client.calculatePKCECodeChallenge(codeVerifier);
+    const oauthState = {
+        state,
+        codeVerifier,
+        codeChallenge,
+        sessionId,
+        provider,
+    };
+    const key = getStateKey(sessionId, provider);
+    oauthStateStore.set(key, oauthState);
+    // Clean up after TTL
+    setTimeout(() => {
+        oauthStateStore.delete(key);
+    }, STATE_TTL_MS);
+    return oauthState;
+}
+function getOAuthState(sessionId, provider, state) {
+    const key = getStateKey(sessionId, provider);
+    const stored = oauthStateStore.get(key);
+    if (!stored || stored.state !== state) {
+        return null;
+    }
+    // Clean up after use
+    oauthStateStore.delete(key);
+    return stored;
+}
+async function createConfiguration(provider) {
+    // LinkedIn uses client_secret_post (form-encoded body parameters)
+    // The library's ClientSecretPost handles this correctly
+    const clientAuth = provider.clientSecret
+        ? client.ClientSecretPost(provider.clientSecret)
+        : client.None();
+    if (provider.issuerConfig) {
+        // Use manual issuer config (e.g., LinkedIn) - create Configuration directly
+        // LinkedIn doesn't support OpenID Connect discovery
+        const serverMetadata = {
+            issuer: provider.issuerConfig.issuer,
+            authorization_endpoint: provider.issuerConfig.authorization_endpoint,
+            token_endpoint: provider.issuerConfig.token_endpoint,
+            ...(provider.issuerConfig.userinfo_endpoint && {
+                userinfo_endpoint: provider.issuerConfig.userinfo_endpoint,
+            }),
+            // LinkedIn JWKS URI for ID token signature verification
+            ...(provider.id === "linkedin" && {
+                jwks_uri: "https://www.linkedin.com/oauth/openid/jwks",
+            }),
+        };
+        const clientMetadata = {
+            client_id: provider.clientId,
+            ...(provider.clientSecret && { client_secret: provider.clientSecret }),
+            redirect_uris: [provider.redirectUri],
+        };
+        return new client.Configuration(serverMetadata, provider.clientId, clientMetadata, clientAuth);
+    }
+    // Auto-discovery from well-known endpoint
+    if (!provider.issuerUrl) {
+        throw new Error("Provider must have either issuerConfig or issuerUrl");
+    }
+    const serverUrl = new URL(provider.issuerUrl);
+    return await client.discovery(serverUrl, provider.clientId, undefined, clientAuth);
+}
+async function buildAuthorizationUrl(provider, state) {
+    const config = await createConfiguration(provider);
+    const parameters = {
+        scope: provider.scopes.join(" "),
+        state: state.state,
+        redirect_uri: provider.redirectUri,
+    };
+    // Add PKCE parameters only if provider supports it
+    if (provider.supportsPKCE !== false) {
+        parameters.code_challenge = state.codeChallenge;
+        parameters.code_challenge_method = "S256";
+    }
+    const url = client.buildAuthorizationUrl(config, parameters);
+    return url.toString();
+}
+async function exchangeCodeForTokens(provider, code, codeVerifier, redirectUri, state) {
+    const logger = logger_1.logger.child({ layer: "exchangeCodeForTokens" });
+    try {
+        // LinkedIn-specific workaround: Manual token exchange to bypass ID token validation
+        // LinkedIn's OpenID Connect ID token has non-standard claim format
+        if (provider.id === "linkedin" && provider.issuerConfig) {
+            const tokenEndpoint = provider.issuerConfig.token_endpoint;
+            const body = new URLSearchParams({
+                grant_type: "authorization_code",
+                code,
+                redirect_uri: provider.redirectUri,
+                client_id: provider.clientId,
+                client_secret: provider.clientSecret,
+            });
+            const response = await fetch(tokenEndpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: body.toString(),
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(`LinkedIn token exchange failed: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
+            }
+            const tokenData = (await response.json());
+            return {
+                accessToken: tokenData.access_token,
+                refreshToken: tokenData.refresh_token,
+                tokenType: tokenData.token_type || "bearer",
+                expiresAt: tokenData.expires_in
+                    ? new Date(Date.now() + tokenData.expires_in * 1000)
+                    : undefined,
+                scope: tokenData.scope,
+            };
+        }
+        // Standard flow for other providers
+        const config = await createConfiguration(provider);
+        const currentUrl = new URL(redirectUri);
+        currentUrl.searchParams.set("code", code);
+        currentUrl.searchParams.set("state", state);
+        const checks = {
+            expectedState: state,
+        };
+        // Only include PKCE verifier if provider supports it
+        if (provider.supportsPKCE !== false) {
+            checks.pkceCodeVerifier = codeVerifier;
+        }
+        const tokenSet = await client.authorizationCodeGrant(config, currentUrl, checks);
+        return {
+            accessToken: tokenSet.access_token,
+            refreshToken: tokenSet.refresh_token,
+            tokenType: tokenSet.token_type,
+            expiresAt: tokenSet.expires_in
+                ? new Date(Date.now() + tokenSet.expires_in * 1000)
+                : undefined,
+            scope: tokenSet.scope,
+        };
+    }
+    catch (error) {
+        // Enhanced error logging for OAuth issues
+        logger.error("Token exchange error", { error, provider: provider.id });
+        if (error instanceof Error) {
+            const errorMessage = error.message || "Unknown error";
+            // Check if this is an ID token validation error for LinkedIn
+            // LinkedIn's ID token may have non-standard claim format, but we can still use the access token
+            if (provider.id === "linkedin" &&
+                errorMessage.includes("JWT claim") &&
+                error.code === "OAUTH_JWT_CLAIM_COMPARISON_FAILED") {
+                // Try to extract access token from the error response if available
+                // This is a workaround for LinkedIn's ID token validation issues
+                logger.warn("LinkedIn ID token validation failed, but token exchange may have succeeded. Check if access token is available.", { error: errorMessage });
+                // Re-throw for now - we need the access token to continue
+                // In a production scenario, you might want to manually parse the token response
+                throw new Error(`LinkedIn ID token validation failed: ${errorMessage}. This is a known issue with LinkedIn's OpenID Connect implementation.`);
+            }
+            // ResponseBodyError from oauth4webapi has a 'cause' property with the error details
+            const responseBodyError = error;
+            const errorDetails = responseBodyError.cause;
+            // Extract error and error_description from LinkedIn's response
+            const linkedInError = errorDetails?.error;
+            const linkedInErrorDescription = errorDetails?.error_description;
+            const fullErrorMessage = linkedInError
+                ? `LinkedIn OAuth error: ${linkedInError}${linkedInErrorDescription ? ` - ${linkedInErrorDescription}` : ""}`
+                : `Token exchange failed: ${errorMessage}${errorDetails ? ` - Details: ${JSON.stringify(errorDetails)}` : ""}`;
+            throw new Error(fullErrorMessage);
+        }
+        throw error;
+    }
+}
+async function refreshAccessToken(provider, refreshToken) {
+    const config = await createConfiguration(provider);
+    const tokenSet = await client.refreshTokenGrant(config, refreshToken);
+    return {
+        accessToken: tokenSet.access_token,
+        refreshToken: tokenSet.refresh_token || refreshToken,
+        tokenType: tokenSet.token_type,
+        expiresAt: tokenSet.expires_in ? new Date(Date.now() + tokenSet.expires_in * 1000) : undefined,
+        scope: tokenSet.scope,
+    };
+}

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

@@ -0,0 +1,414 @@
+import type { InferInsertModel, InferSelectModel } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import { BaseTableRepository } from "#modules/base/base.repository";
+import type { ConnectListInputSchema } from "#modules/connect/connect.dto";
+declare const schema: {
+    connect: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "connect";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "connect";
+                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;
+            }>;
+            userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "user_id";
+                tableName: "connect";
+                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;
+            }>;
+            provider: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "provider";
+                tableName: "connect";
+                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;
+            }>;
+            accountType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "account_type";
+                tableName: "connect";
+                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;
+            }>;
+            providerAccountId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "provider_account_id";
+                tableName: "connect";
+                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;
+            }>;
+            handle: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "handle";
+                tableName: "connect";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            displayName: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "display_name";
+                tableName: "connect";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            avatarUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "avatar_url";
+                tableName: "connect";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            accessToken: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "access_token";
+                tableName: "connect";
+                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;
+            }>;
+            refreshToken: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "refresh_token";
+                tableName: "connect";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            tokenType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "token_type";
+                tableName: "connect";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "scope";
+                tableName: "connect";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "expires_at";
+                tableName: "connect";
+                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;
+            }, {}, {}>;
+            parentId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "parent_id";
+                tableName: "connect";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            metadataJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "metadata_json";
+                tableName: "connect";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: unknown;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            revokedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "revoked_at";
+                tableName: "connect";
+                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;
+            }, {}, {}>;
+            lastRefreshedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "last_refreshed_at";
+                tableName: "connect";
+                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;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "connect";
+                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: "connect";
+                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;
+            }, {}, {}>;
+        };
+        dialect: "sqlite";
+    }>;
+};
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+export type ConnectRow = InferSelectModel<Schema["connect"]>;
+export type ConnectInsert = InferInsertModel<Schema["connect"]>;
+export declare class ConnectRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["connect"]> {
+    list(data: ConnectListInputSchema & {
+        userId: string;
+    }, tx?: Orm): Promise<import("../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;
+    }[]>>;
+    upsert(data: ConnectInsert, tx?: Orm): Promise<import("../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;
+    }>>;
+}
+export {};
+//# sourceMappingURL=connect.repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAE3E,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAiB,CAAC;AAC9B,KAAK,MAAM,GAAG,OAAO,MAAM,CAAC;AAC5B,KAAK,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAElC,MAAM,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AAC7D,MAAM,MAAM,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AAEhE,qBAAa,iBAAkB,SAAQ,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;IACzG,IAAI,CAAC,IAAI,EAAE,sBAAsB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,EAAE,CAAC,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;IAahE,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,CAAC,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;CAmC3C"}

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

@@ -0,0 +1,5 @@
+import { Router } from "express";
+import type { AuthMiddleware } from "#modules/auth/auth.middleware";
+import type { ConnectService } from "./connect.service";
+export declare function createConnectRouter(authMiddleware: AuthMiddleware, connectService: ConnectService): Router;
+//# sourceMappingURL=connect.router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.router.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAgB,mBAAmB,CACjC,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,cAAc,GAC7B,MAAM,CAoER"}