feat: implement automation key management with middleware and routes for organization API keys, invite improvements

packages/db/src/queries/auth/profile.ts

@@ -26,8 +26,5 @@ export const markUserAndProfileEmailVerified = async (userId: string, dbClient:
   const verifiedAt = new Date().toISOString();
 
   await dbClient.update(schema.user).set({ emailVerified: true }).where(eq(schema.user.id, userId));
-  await dbClient
-    .update(schema.profile)
-    .set({ isEmailVerified: true, verifiedAt })
-    .where(eq(schema.profile.id, userId));
+  await dbClient.update(schema.profile).set({ isEmailVerified: true, verifiedAt }).where(eq(schema.profile.id, userId));
 };

packages/db/src/queries/course-import/course-import.ts

@@ -0,0 +1,81 @@
+import * as schema from '@db/schema';
+
+import { and, eq } from 'drizzle-orm';
+
+import { db } from '@db/drizzle';
+import type { TCourseImportDraft, TNewCourseImportDraft } from '@db/types';
+
+export async function createCourseImportDraft(data: TNewCourseImportDraft): Promise<TCourseImportDraft> {
+  try {
+    const [draft] = await db.insert(schema.courseImportDraft).values(data).returning();
+
+    if (!draft) {
+      throw new Error('Failed to create course import draft');
+    }
+
+    return draft;
+  } catch (error) {
+    console.error('createCourseImportDraft error:', error);
+    throw new Error('Failed to create course import draft');
+  }
+}
+
+export async function getCourseImportDraftById(orgId: string, draftId: string): Promise<TCourseImportDraft | null> {
+  try {
+    const [draft] = await db
+      .select()
+      .from(schema.courseImportDraft)
+      .where(and(eq(schema.courseImportDraft.organizationId, orgId), eq(schema.courseImportDraft.id, draftId)))
+      .limit(1);
+
+    return draft || null;
+  } catch (error) {
+    console.error('getCourseImportDraftById error:', error);
+    throw new Error('Failed to fetch course import draft');
+  }
+}
+
+export async function getCourseImportDraftByIdempotencyKey(
+  orgId: string,
+  idempotencyKey: string
+): Promise<TCourseImportDraft | null> {
+  try {
+    const [draft] = await db
+      .select()
+      .from(schema.courseImportDraft)
+      .where(
+        and(
+          eq(schema.courseImportDraft.organizationId, orgId),
+          eq(schema.courseImportDraft.idempotencyKey, idempotencyKey)
+        )
+      )
+      .limit(1);
+
+    return draft || null;
+  } catch (error) {
+    console.error('getCourseImportDraftByIdempotencyKey error:', error);
+    throw new Error('Failed to fetch course import draft by idempotency key');
+  }
+}
+
+export async function updateCourseImportDraft(
+  orgId: string,
+  draftId: string,
+  data: Partial<TCourseImportDraft>
+): Promise<TCourseImportDraft | null> {
+  try {
+    const [draft] = await db
+      .update(schema.courseImportDraft)
+      .set({
+        ...data,
+        updatedAt: new Date().toISOString()
+      })
+      .where(and(eq(schema.courseImportDraft.organizationId, orgId), eq(schema.courseImportDraft.id, draftId)))
+      .returning();
+
+    return draft || null;
+  } catch (error) {
+    console.error('updateCourseImportDraft error:', error);
+    throw new Error('Failed to update course import draft');
+  }
+}

packages/db/src/queries/course-import/index.ts

@@ -0,0 +1 @@
+export * from './course-import';

packages/db/src/queries/index.ts

@@ -11,3 +11,4 @@ export * from './mark';
 export * from './newsfeed';
 export * from './submission';
 export * from './tag';
+export * from './course-import';

packages/db/src/queries/organization/automation-key.ts

@@ -0,0 +1,98 @@
+import * as schema from '@db/schema';
+
+import { and, desc, eq, isNull } from 'drizzle-orm';
+
+import { db } from '@db/drizzle';
+import type { TNewOrganizationApiKey, TOrganizationApiKey, TOrganizationApiKeyType } from '@db/types';
+
+export const createOrganizationApiKey = async (data: TNewOrganizationApiKey): Promise<TOrganizationApiKey> => {
+  try {
+    const [row] = await db.insert(schema.organizationApiKey).values(data).returning();
+
+    if (!row) {
+      throw new Error('Failed to create organization API key');
+    }
+
+    return row;
+  } catch (error) {
+    console.error('createOrganizationApiKey error:', error);
+    throw new Error('Failed to create organization API key');
+  }
+};
+
+export const listOrganizationApiKeys = async (
+  organizationId: string,
+  type?: TOrganizationApiKeyType
+): Promise<TOrganizationApiKey[]> => {
+  try {
+    const conditions = [eq(schema.organizationApiKey.organizationId, organizationId)];
+
+    if (type) {
+      conditions.push(eq(schema.organizationApiKey.type, type));
+    }
+
+    return db
+      .select()
+      .from(schema.organizationApiKey)
+      .where(and(...conditions))
+      .orderBy(desc(schema.organizationApiKey.createdAt));
+  } catch (error) {
+    console.error('listOrganizationApiKeys error:', error);
+    throw new Error('Failed to list organization API keys');
+  }
+};
+
+export const getOrganizationApiKeyById = async (
+  organizationId: string,
+  keyId: string
+): Promise<TOrganizationApiKey | null> => {
+  try {
+    const [row] = await db
+      .select()
+      .from(schema.organizationApiKey)
+      .where(and(eq(schema.organizationApiKey.organizationId, organizationId), eq(schema.organizationApiKey.id, keyId)))
+      .limit(1);
+
+    return row || null;
+  } catch (error) {
+    console.error('getOrganizationApiKeyById error:', error);
+    throw new Error('Failed to get organization API key by id');
+  }
+};
+
+export const getActiveOrganizationApiKeyByHash = async (secretHash: string): Promise<TOrganizationApiKey | null> => {
+  try {
+    const [row] = await db
+      .select()
+      .from(schema.organizationApiKey)
+      .where(and(eq(schema.organizationApiKey.secretHash, secretHash), isNull(schema.organizationApiKey.revokedAt)))
+      .limit(1);
+
+    return row || null;
+  } catch (error) {
+    console.error('getActiveOrganizationApiKeyByHash error:', error);
+    throw new Error('Failed to get organization API key by hash');
+  }
+};
+
+export const updateOrganizationApiKey = async (
+  organizationId: string,
+  keyId: string,
+  data: Partial<TOrganizationApiKey>
+): Promise<TOrganizationApiKey | null> => {
+  try {
+    const [row] = await db
+      .update(schema.organizationApiKey)
+      .set({
+        ...data,
+        updatedAt: new Date().toISOString()
+      })
+      .where(and(eq(schema.organizationApiKey.organizationId, organizationId), eq(schema.organizationApiKey.id, keyId)))
+      .returning();
+
+    return row || null;
+  } catch (error) {
+    console.error('updateOrganizationApiKey error:', error);
+    throw new Error('Failed to update organization API key');
+  }
+};

packages/db/src/queries/organization/index.ts

@@ -1,3 +1,4 @@
 export * from './organization';
 export * from './quiz';
 export * from './invite';
+export * from './automation-key';