cleanup

Author: brendan-kellam

packages/web/src/actions.ts

@@ -13,7 +13,7 @@ import { giteaSchema } from "@sourcebot/schemas/v3/gitea.schema";
 import { gerritSchema } from "@sourcebot/schemas/v3/gerrit.schema";
 import { GithubConnectionConfig, GitlabConnectionConfig, GiteaConnectionConfig, GerritConnectionConfig, ConnectionConfig } from "@sourcebot/schemas/v3/connection.type";
 import { encrypt } from "@sourcebot/crypto"
-import { getConnection, getLinkedRepos } from "./data/connection";
+import { getConnection } from "./data/connection";
 import { ConnectionSyncStatus, Prisma, OrgRole, RepoIndexingStatus, StripeSubscriptionStatus } from "@sourcebot/db";
 import { headers } from "next/headers"
 import { getStripe } from "@/lib/stripe"
@@ -278,7 +278,7 @@ export const getConnections = async (domain: string, filter: { status?: Connecti
                 connectionType: connection.connectionType,
                 updatedAt: connection.updatedAt,
                 syncedAt: connection.syncedAt ?? undefined,
-                linkedRepos: connection.repos.map(( { repo }) => ({
+                linkedRepos: connection.repos.map(({ repo }) => ({
                     id: repo.id,
                     name: repo.name,
                     repoIndexingStatus: repo.repoIndexingStatus,
@@ -317,23 +317,6 @@ export const getConnectionInfo = async (connectionId: number, domain: string) =>
         })
     )
 
-export const getConnectionFailedRepos = async (connectionId: number, domain: string): Promise<{ repoId: number, repoName: string }[] | ServiceError> =>
-    withAuth((session) =>
-        withOrgMembership(session, domain, async ({ orgId }) => {
-            const connection = await getConnection(connectionId, orgId);
-            if (!connection) {
-                return notFound();
-            }
-
-            const linkedRepos = await getLinkedRepos(connectionId, orgId);
-
-            return linkedRepos.filter((repo) => repo.repo.repoIndexingStatus === RepoIndexingStatus.FAILED).map((repo) => ({
-                repoId: repo.repo.id,
-                repoName: repo.repo.name,
-            }));
-        })
-    );
-
 export const getRepos = async (domain: string, filter: { status?: RepoIndexingStatus[], connectionId?: number } = {}) =>
     withAuth((session) =>
         withOrgMembership(session, domain, async ({ orgId }) => {
@@ -367,7 +350,6 @@ export const getRepos = async (domain: string, filter: { status?: RepoIndexingSt
         })
     );
 
-
 export const createConnection = async (name: string, type: string, connectionConfig: string, domain: string): Promise<{ id: number } | ServiceError> =>
     withAuth((session) =>
         withOrgMembership(session, domain, async ({ orgId }) => {
@@ -493,36 +475,6 @@ export const flagReposForIndex = async (repoIds: number[], domain: string) =>
         })
     );
 
-export const flagRepoForIndex = async (repoId: number, domain: string): Promise<{ success: boolean } | ServiceError> =>
-    withAuth((session) =>
-        withOrgMembership(session, domain, async () => {
-            const repo = await prisma.repo.findUnique({
-                where: {
-                    id: repoId,
-                },
-            });
-
-            if (!repo) {
-                return notFound();
-            }
-
-            await prisma.repo.update({
-                where: {
-                    id: repoId,
-                },
-                data: {
-                    repoIndexingStatus: RepoIndexingStatus.NEW,
-                }
-            });
-
-            return {
-                success: true,
-            }
-        })
-    );
-
-
-
 export const deleteConnection = async (connectionId: number, domain: string): Promise<{ success: boolean } | ServiceError> =>
     withAuth((session) =>
         withOrgMembership(session, domain, async ({ orgId }) => {
@@ -689,7 +641,6 @@ export const cancelInvite = async (inviteId: string, domain: string): Promise<{
         }, /* minRequiredRole = */ OrgRole.OWNER)
     );
 
-
 export const redeemInvite = async (inviteId: string): Promise<{ success: boolean } | ServiceError> =>
     withAuth(async (session) => {
         const invite = await prisma.invite.findUnique({
@@ -863,97 +814,6 @@ export const transferOwnership = async (newOwnerId: string, domain: string): Pro
         }, /* minRequiredRole = */ OrgRole.OWNER)
     );
 
-const parseConnectionConfig = (connectionType: string, config: string) => {
-    let parsedConfig: ConnectionConfig;
-    try {
-        parsedConfig = JSON.parse(config);
-    } catch (_e) {
-        return {
-            statusCode: StatusCodes.BAD_REQUEST,
-            errorCode: ErrorCode.INVALID_REQUEST_BODY,
-            message: "config must be a valid JSON object."
-        } satisfies ServiceError;
-    }
-
-    const schema = (() => {
-        switch (connectionType) {
-            case "github":
-                return githubSchema;
-            case "gitlab":
-                return gitlabSchema;
-            case 'gitea':
-                return giteaSchema;
-            case 'gerrit':
-                return gerritSchema;
-        }
-    })();
-
-    if (!schema) {
-        return {
-            statusCode: StatusCodes.BAD_REQUEST,
-            errorCode: ErrorCode.INVALID_REQUEST_BODY,
-            message: "invalid connection type",
-        } satisfies ServiceError;
-    }
-
-    const { numRepos, hasToken } = (() => {
-        switch (connectionType) {
-            case "github": {
-                const githubConfig = parsedConfig as GithubConnectionConfig;
-                return {
-                    numRepos: githubConfig.repos?.length,
-                    hasToken: !!githubConfig.token,
-                }
-            }
-            case "gitlab": {
-                const gitlabConfig = parsedConfig as GitlabConnectionConfig;
-                return {
-                    numRepos: gitlabConfig.projects?.length,
-                    hasToken: !!gitlabConfig.token,
-                }
-            }
-            case "gitea": {
-                const giteaConfig = parsedConfig as GiteaConnectionConfig;
-                return {
-                    numRepos: giteaConfig.repos?.length,
-                    hasToken: !!giteaConfig.token,
-                }
-            }
-            case "gerrit": {
-                const gerritConfig = parsedConfig as GerritConnectionConfig;
-                return {
-                    numRepos: gerritConfig.projects?.length,
-                    hasToken: true, // gerrit doesn't use a token atm
-                }
-            }
-            default:
-                return {
-                    numRepos: undefined,
-                    hasToken: true
-                }
-        }
-    })();
-
-    if (!hasToken && numRepos && numRepos > CONFIG_MAX_REPOS_NO_TOKEN) {
-        return {
-            statusCode: StatusCodes.BAD_REQUEST,
-            errorCode: ErrorCode.INVALID_REQUEST_BODY,
-            message: `You must provide a token to sync more than ${CONFIG_MAX_REPOS_NO_TOKEN} repositories.`,
-        } satisfies ServiceError;
-    }
-
-    const isValidConfig = ajv.validate(schema, parsedConfig);
-    if (!isValidConfig) {
-        return {
-            statusCode: StatusCodes.BAD_REQUEST,
-            errorCode: ErrorCode.INVALID_REQUEST_BODY,
-            message: `config schema validation failed with errors: ${ajv.errorsText(ajv.errors)}`,
-        } satisfies ServiceError;
-    }
-
-    return parsedConfig;
-}
-
 export const createOnboardingStripeCheckoutSession = async (domain: string) =>
     withAuth(async (session) =>
         withOrgMembership(session, domain, async ({ orgId }) => {
@@ -1106,8 +966,6 @@ export const createStripeCheckoutSession = async (domain: string) =>
         })
     )
 
-
-
 export const getCustomerPortalSessionLink = async (domain: string): Promise<string | ServiceError> =>
     withAuth((session) =>
         withOrgMembership(session, domain, async ({ orgId }) => {
@@ -1139,32 +997,6 @@ export const fetchSubscription = (domain: string): Promise<Stripe.Subscription |
         })
     );
 
-const _fetchSubscriptionForOrg = async (orgId: number, prisma: Prisma.TransactionClient): Promise<Stripe.Subscription | null | ServiceError> => {
-    const org = await prisma.org.findUnique({
-        where: {
-            id: orgId,
-        },
-    });
-
-    if (!org) {
-        return notFound();
-    }
-
-    if (!org.stripeCustomerId) {
-        return null;
-    }
-
-    const stripe = getStripe();
-    const subscriptions = await stripe.subscriptions.list({
-        customer: org.stripeCustomerId
-    });
-
-    if (subscriptions.data.length === 0) {
-        return orgInvalidSubscription();
-    }
-    return subscriptions.data[0];
-}
-
 export const getSubscriptionBillingEmail = async (domain: string): Promise<string | ServiceError> =>
     withAuth(async (session) =>
         withOrgMembership(session, domain, async ({ orgId }) => {
@@ -1211,16 +1043,6 @@ export const changeSubscriptionBillingEmail = async (domain: string, newEmail: s
         }, /* minRequiredRole = */ OrgRole.OWNER)
     );
 
-export const checkIfUserHasOrg = async (userId: string): Promise<boolean | ServiceError> => {
-    const orgs = await prisma.userToOrg.findMany({
-        where: {
-            userId,
-        },
-    });
-
-    return orgs.length > 0;
-}
-
 export const checkIfOrgDomainExists = async (domain: string): Promise<boolean | ServiceError> =>
     withAuth(async () => {
         const org = await prisma.org.findFirst({
@@ -1392,7 +1214,6 @@ export const getOrgMembers = async (domain: string) =>
         })
     );
 
-
 export const getOrgInvites = async (domain: string) =>
     withAuth(async (session) =>
         withOrgMembership(session, domain, async ({ orgId }) => {
@@ -1409,3 +1230,123 @@ export const getOrgInvites = async (domain: string) =>
             }));
         })
     );
+
+
+////// Helpers ///////
+
+const _fetchSubscriptionForOrg = async (orgId: number, prisma: Prisma.TransactionClient): Promise<Stripe.Subscription | null | ServiceError> => {
+    const org = await prisma.org.findUnique({
+        where: {
+            id: orgId,
+        },
+    });
+
+    if (!org) {
+        return notFound();
+    }
+
+    if (!org.stripeCustomerId) {
+        return null;
+    }
+
+    const stripe = getStripe();
+    const subscriptions = await stripe.subscriptions.list({
+        customer: org.stripeCustomerId
+    });
+
+    if (subscriptions.data.length === 0) {
+        return orgInvalidSubscription();
+    }
+    return subscriptions.data[0];
+}
+
+const parseConnectionConfig = (connectionType: string, config: string) => {
+    let parsedConfig: ConnectionConfig;
+    try {
+        parsedConfig = JSON.parse(config);
+    } catch (_e) {
+        return {
+            statusCode: StatusCodes.BAD_REQUEST,
+            errorCode: ErrorCode.INVALID_REQUEST_BODY,
+            message: "config must be a valid JSON object."
+        } satisfies ServiceError;
+    }
+
+    const schema = (() => {
+        switch (connectionType) {
+            case "github":
+                return githubSchema;
+            case "gitlab":
+                return gitlabSchema;
+            case 'gitea':
+                return giteaSchema;
+            case 'gerrit':
+                return gerritSchema;
+        }
+    })();
+
+    if (!schema) {
+        return {
+            statusCode: StatusCodes.BAD_REQUEST,
+            errorCode: ErrorCode.INVALID_REQUEST_BODY,
+            message: "invalid connection type",
+        } satisfies ServiceError;
+    }
+
+    const { numRepos, hasToken } = (() => {
+        switch (connectionType) {
+            case "github": {
+                const githubConfig = parsedConfig as GithubConnectionConfig;
+                return {
+                    numRepos: githubConfig.repos?.length,
+                    hasToken: !!githubConfig.token,
+                }
+            }
+            case "gitlab": {
+                const gitlabConfig = parsedConfig as GitlabConnectionConfig;
+                return {
+                    numRepos: gitlabConfig.projects?.length,
+                    hasToken: !!gitlabConfig.token,
+                }
+            }
+            case "gitea": {
+                const giteaConfig = parsedConfig as GiteaConnectionConfig;
+                return {
+                    numRepos: giteaConfig.repos?.length,
+                    hasToken: !!giteaConfig.token,
+                }
+            }
+            case "gerrit": {
+                const gerritConfig = parsedConfig as GerritConnectionConfig;
+                return {
+                    numRepos: gerritConfig.projects?.length,
+                    hasToken: true, // gerrit doesn't use a token atm
+                }
+            }
+            default:
+                return {
+                    numRepos: undefined,
+                    hasToken: true
+                }
+        }
+    })();
+
+    if (!hasToken && numRepos && numRepos > CONFIG_MAX_REPOS_NO_TOKEN) {
+        return {
+            statusCode: StatusCodes.BAD_REQUEST,
+            errorCode: ErrorCode.INVALID_REQUEST_BODY,
+            message: `You must provide a token to sync more than ${CONFIG_MAX_REPOS_NO_TOKEN} repositories.`,
+        } satisfies ServiceError;
+    }
+
+    const isValidConfig = ajv.validate(schema, parsedConfig);
+    if (!isValidConfig) {
+        return {
+            statusCode: StatusCodes.BAD_REQUEST,
+            errorCode: ErrorCode.INVALID_REQUEST_BODY,
+            message: `config schema validation failed with errors: ${ajv.errorsText(ajv.errors)}`,
+        } satisfies ServiceError;
+    }
+
+    return parsedConfig;
+}