@superinterface/server 1.0.24 → 1.0.26

package/dist/app/api/api-keys/[apiKeyId]/buildRoute.js

@@ -0,0 +1,121 @@
+import { NextResponse } from 'next/server';
+import { ApiKeyType } from '@prisma/client';
+import { headers } from 'next/headers';
+import { cacheHeaders } from '../../../../lib/cache/cacheHeaders';
+import { serializeApiKey } from '../../../../lib/apiKeys/serializeApiKey';
+import { z } from 'zod';
+import { getApiKey } from '../../../../lib/apiKeys/getApiKey';
+import { validate } from 'uuid';
+const ensureValidApiKeyId = (apiKeyId) => {
+    if (!validate(apiKeyId)) {
+        return NextResponse.json({ error: 'Invalid api key id' }, { status: 400 });
+    }
+    return null;
+};
+export const buildGET = ({ prisma }) => async (_request, props) => {
+    const { apiKeyId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = ensureValidApiKeyId(apiKeyId);
+    if (validationError)
+        return validationError;
+    const apiKey = await prisma.apiKey.findFirst({
+        where: {
+            id: apiKeyId,
+            type: ApiKeyType.PUBLIC,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    if (!apiKey) {
+        return NextResponse.json({ error: 'No api key found' }, { status: 400 });
+    }
+    return NextResponse.json({ apiKey: serializeApiKey({ apiKey }) }, { headers: cacheHeaders });
+};
+export const buildPATCH = ({ prisma }) => async (request, props) => {
+    const { apiKeyId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        authorization,
+        type: ApiKeyType.PRIVATE,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = ensureValidApiKeyId(apiKeyId);
+    if (validationError)
+        return validationError;
+    const body = await request.json().catch(() => null);
+    const schema = z.object({ name: z.string().min(1) });
+    const parsed = schema.safeParse(body);
+    if (!parsed.success) {
+        return NextResponse.json({ error: 'No name found' }, { status: 400 });
+    }
+    const { name } = parsed.data;
+    const existingApiKey = await prisma.apiKey.findFirst({
+        where: {
+            id: apiKeyId,
+            type: ApiKeyType.PUBLIC,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    if (!existingApiKey) {
+        return NextResponse.json({ error: 'No api key found' }, { status: 400 });
+    }
+    const apiKey = await prisma.apiKey.update({
+        where: { id: apiKeyId },
+        data: { name },
+    });
+    return NextResponse.json({ apiKey: serializeApiKey({ apiKey }) }, { headers: cacheHeaders });
+};
+export const buildDELETE = ({ prisma }) => async (_request, props) => {
+    const { apiKeyId } = await props.params;
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const validationError = ensureValidApiKeyId(apiKeyId);
+    if (validationError)
+        return validationError;
+    const apiKey = await prisma.apiKey.findFirst({
+        where: {
+            id: apiKeyId,
+            type: ApiKeyType.PUBLIC,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    if (!apiKey) {
+        return NextResponse.json({ error: 'No api key found' }, { status: 400 });
+    }
+    const deletedApiKey = await prisma.apiKey.delete({
+        where: { id: apiKey.id },
+    });
+    return NextResponse.json({ apiKey: serializeApiKey({ apiKey: deletedApiKey }) }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/api-keys/[apiKeyId]/route.d.ts

@@ -1,14 +1,10 @@
-import { type NextRequest, NextResponse } from 'next/server';
-import { type PrismaClient } from '@prisma/client';
-export declare const buildGET: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest, props: {
+export declare const GET: (_request: import("next/server").NextRequest, props: {
     params: Promise<{
         apiKeyId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     apiKey: {
         id: string;
         type: import("@prisma/client").$Enums.ApiKeyType;
@@ -18,16 +14,13 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const GET: ReturnType<typeof buildGET>;
-export declare const buildPATCH: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest, props: {
+export declare const PATCH: (request: import("next/server").NextRequest, props: {
     params: Promise<{
         apiKeyId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     apiKey: {
         id: string;
         type: import("@prisma/client").$Enums.ApiKeyType;
@@ -37,16 +30,13 @@ export declare const buildPATCH: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const PATCH: ReturnType<typeof buildPATCH>;
-export declare const buildDELETE: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: NextRequest, props: {
+export declare const DELETE: (_request: import("next/server").NextRequest, props: {
     params: Promise<{
         apiKeyId: string;
     }>;
-}) => Promise<NextResponse<{
+}) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     apiKey: {
         id: string;
         type: import("@prisma/client").$Enums.ApiKeyType;
@@ -56,6 +46,5 @@ export declare const buildDELETE: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const DELETE: ReturnType<typeof buildDELETE>;
-export declare const OPTIONS: () => NextResponse<{}>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/api-keys/[apiKeyId]/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/api-keys/[apiKeyId]/route.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC5D,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAS9D,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACtC;;;;;;;;;;;GA6CF,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,UAAU,GACpB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACtC;;;;;;;;;;;GA4DF,CAAA;AAEH,eAAO,MAAM,KAAK,EACU,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;AAEzD,eAAO,MAAM,WAAW,GACrB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MAEzD,SAAS,WAAW,EACpB,OAAO;IACL,MAAM,EAAE,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACtC;;;;;;;;;;;GAgDF,CAAA;AAEH,eAAO,MAAM,MAAM,EACU,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA;AAE3D,eAAO,MAAM,OAAO,wBAMjB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/api-keys/[apiKeyId]/route.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;GAAuB,CAAA;AAEvC,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;GAAyB,CAAA;AAE3C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;GAA0B,CAAA;AAE7C,eAAO,MAAM,OAAO,8CAAiB,CAAA"}

package/dist/app/api/api-keys/[apiKeyId]/route.js

@@ -1,125 +1,6 @@
-import { NextResponse } from 'next/server';
-import { ApiKeyType } from '@prisma/client';
-import { headers } from 'next/headers';
-import { cacheHeaders } from '../../../../lib/cache/cacheHeaders';
-import { resolvePrisma } from '../../../../lib/prisma';
-import { serializeApiKey } from '../../../../lib/apiKeys/serializeApiKey';
-import { z } from 'zod';
-import { getApiKey } from '../../../../lib/apiKeys/getApiKey';
-import { validate } from 'uuid';
-export const buildGET = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const params = await props.params;
-    const { apiKeyId } = params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        type: ApiKeyType.PRIVATE,
-        authorization,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(apiKeyId)) {
-        return NextResponse.json({ error: 'Invalid api key id' }, { status: 400 });
-    }
-    const apiKey = await prisma.apiKey.findFirst({
-        where: {
-            id: apiKeyId,
-            type: ApiKeyType.PUBLIC,
-            workspaceId: privateApiKey.workspaceId,
-        },
-    });
-    if (!apiKey) {
-        return NextResponse.json({ error: 'No api key found' }, { status: 400 });
-    }
-    return NextResponse.json({ apiKey: serializeApiKey({ apiKey }) }, { headers: cacheHeaders });
-};
-export const GET = ((...args) => buildGET()(...args));
-export const buildPATCH = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const params = await props.params;
-    const { apiKeyId } = params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        authorization,
-        type: ApiKeyType.PRIVATE,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(apiKeyId)) {
-        return NextResponse.json({ error: 'Invalid api key id' }, { status: 400 });
-    }
-    const body = await request.json().catch(() => null);
-    const schema = z.object({ name: z.string().min(1) });
-    const parsed = schema.safeParse(body);
-    if (!parsed.success) {
-        return NextResponse.json({ error: 'No name found' }, { status: 400 });
-    }
-    const { name } = parsed.data;
-    const existingApiKey = await prisma.apiKey.findFirst({
-        where: {
-            id: apiKeyId,
-            type: ApiKeyType.PUBLIC,
-            workspaceId: privateApiKey.workspaceId,
-        },
-    });
-    if (!existingApiKey) {
-        return NextResponse.json({ error: 'No api key found' }, { status: 400 });
-    }
-    const apiKey = await prisma.apiKey.update({
-        where: { id: apiKeyId },
-        data: { name },
-    });
-    return NextResponse.json({ apiKey: serializeApiKey({ apiKey }) }, { headers: cacheHeaders });
-};
-export const PATCH = ((...args) => buildPATCH()(...args));
-export const buildDELETE = ({ prisma: providedPrisma } = {}) => async (request, props) => {
-    const prisma = resolvePrisma(providedPrisma);
-    const params = await props.params;
-    const { apiKeyId } = params;
-    const headersList = await headers();
-    const authorization = headersList.get('authorization');
-    if (!authorization) {
-        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
-    }
-    const privateApiKey = await getApiKey({
-        type: ApiKeyType.PRIVATE,
-        authorization,
-        prisma,
-    });
-    if (!privateApiKey) {
-        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
-    }
-    if (!validate(apiKeyId)) {
-        return NextResponse.json({ error: 'Invalid api key id' }, { status: 400 });
-    }
-    const apiKey = await prisma.apiKey.findFirst({
-        where: {
-            id: apiKeyId,
-            type: ApiKeyType.PUBLIC,
-            workspaceId: privateApiKey.workspaceId,
-        },
-    });
-    if (!apiKey) {
-        return NextResponse.json({ error: 'No api key found' }, { status: 400 });
-    }
-    const deletedApiKey = await prisma.apiKey.delete({
-        where: { id: apiKey.id },
-    });
-    return NextResponse.json({ apiKey: serializeApiKey({ apiKey: deletedApiKey }) }, { headers: cacheHeaders });
-};
-export const DELETE = ((...args) => buildDELETE()(...args));
-export const OPTIONS = () => NextResponse.json({}, {
-    headers: cacheHeaders,
-});
+import { prisma } from '../../../../lib/prisma';
+import { buildDELETE, buildGET, buildOPTIONS, buildPATCH, } from './buildRoute';
+export const GET = buildGET({ prisma });
+export const PATCH = buildPATCH({ prisma });
+export const DELETE = buildDELETE({ prisma });
+export const OPTIONS = buildOPTIONS();

package/dist/app/api/api-keys/buildRoute.d.ts

@@ -0,0 +1,32 @@
+import { type PrismaClient } from '@prisma/client';
+import { NextResponse } from 'next/server';
+export declare const buildGET: ({ prisma }: {
+    prisma: PrismaClient;
+}) => () => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    apiKeys: {
+        id: string;
+        type: import("@prisma/client").$Enums.ApiKeyType;
+        name: string;
+        value: string;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+}>>;
+export declare const buildPOST: ({ prisma }: {
+    prisma: PrismaClient;
+}) => (request: Request) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    apiKey: {
+        id: string;
+        type: import("@prisma/client").$Enums.ApiKeyType;
+        name: string;
+        value: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+}>>;
+export declare const buildOPTIONS: () => () => NextResponse<{}>;
+//# sourceMappingURL=buildRoute.d.ts.map

package/dist/app/api/api-keys/buildRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRoute.d.ts","sourceRoot":"","sources":["../../../../src/app/api/api-keys/buildRoute.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAO1C,eAAO,MAAM,QAAQ,GAAI,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE;;;;;;;;;;;GAkC1D,CAAA;AAEH,eAAO,MAAM,SAAS,GAAI,YAAY;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,MACrD,SAAS,OAAO;;;;;;;;;;;GAmGtB,CAAA;AAEH,eAAO,MAAM,YAAY,8BAMtB,CAAA"}

package/dist/app/api/api-keys/buildRoute.js

@@ -0,0 +1,104 @@
+import { headers } from 'next/headers';
+import { ApiKeyType } from '@prisma/client';
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+import { cacheHeaders } from '../../../lib/cache/cacheHeaders';
+import { serializeApiKey } from '../../../lib/apiKeys/serializeApiKey';
+import { getApiKey } from '../../../lib/apiKeys/getApiKey';
+import { getOrganizationApiKey } from '../../../lib/organizationApiKeys/getOrganizationApiKey';
+export const buildGET = ({ prisma }) => async () => {
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const apiKeys = await prisma.apiKey.findMany({
+        where: {
+            type: ApiKeyType.PUBLIC,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    return NextResponse.json({
+        apiKeys: apiKeys.map((apiKey) => serializeApiKey({ apiKey })),
+    }, { headers: cacheHeaders });
+};
+export const buildPOST = ({ prisma }) => async (request) => {
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const body = await request.json().catch(() => null);
+    const organizationApiKey = await getOrganizationApiKey({
+        authorization,
+        prisma,
+    });
+    if (organizationApiKey) {
+        const createSchemaOrganizationApiKey = z.object({
+            name: z.string().min(1).optional(),
+            type: z.nativeEnum(ApiKeyType),
+            workspaceId: z.string().min(1).optional(),
+        });
+        const parsedOrganizationApiKey = createSchemaOrganizationApiKey.safeParse(body);
+        if (!parsedOrganizationApiKey.success) {
+            return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
+        }
+        const workspace = await prisma.workspace.findUnique({
+            where: {
+                id: parsedOrganizationApiKey.data.workspaceId,
+                organizationId: organizationApiKey.organizationId,
+            },
+        });
+        if (!workspace) {
+            return NextResponse.json({ error: 'Invalid workspace' }, { status: 400 });
+        }
+        const apiKey = await prisma.apiKey.create({
+            data: {
+                type: parsedOrganizationApiKey.data.type,
+                name: parsedOrganizationApiKey.data.name,
+                workspaceId: workspace.id,
+            },
+        });
+        return NextResponse.json({
+            apiKey: serializeApiKey({ apiKey }),
+        }, { headers: cacheHeaders });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const createSchema = z.object({
+        name: z.string().min(1).optional(),
+    });
+    const parsed = createSchema.safeParse(body);
+    if (!parsed.success) {
+        return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
+    }
+    const { name } = parsed.data;
+    const workspaceId = privateApiKey.workspaceId;
+    const apiKey = await prisma.apiKey.create({
+        data: {
+            type: ApiKeyType.PUBLIC,
+            name,
+            workspaceId,
+        },
+    });
+    return NextResponse.json({
+        apiKey: serializeApiKey({ apiKey }),
+    }, { headers: cacheHeaders });
+};
+export const buildOPTIONS = () => () => NextResponse.json({}, {
+    headers: cacheHeaders,
+});

package/dist/app/api/api-keys/builders.d.ts

@@ -0,0 +1,31 @@
+import { type PrismaClient } from '@prisma/client';
+import { NextResponse } from 'next/server';
+export declare const buildGET: ({ prisma: providedPrisma }?: {
+    prisma?: PrismaClient;
+}) => () => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    apiKeys: {
+        id: string;
+        type: import("@prisma/client").$Enums.ApiKeyType;
+        name: string;
+        value: string;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+}>>;
+export declare const buildPOST: ({ prisma: providedPrisma }?: {
+    prisma?: PrismaClient;
+}) => (request: Request) => Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    apiKey: {
+        id: string;
+        type: import("@prisma/client").$Enums.ApiKeyType;
+        name: string;
+        value: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+}>>;
+//# sourceMappingURL=builders.d.ts.map

package/dist/app/api/api-keys/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../../../src/app/api/api-keys/builders.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAU1C,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO;;;;;;;;;;;GAsC1D,CAAA;AAEH,eAAO,MAAM,SAAS,GACnB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MACpD,SAAS,OAAO;;;;;;;;;;;GAuGtB,CAAA"}

package/dist/app/api/api-keys/builders.js

@@ -0,0 +1,109 @@
+import { headers } from 'next/headers';
+import { ApiKeyType } from '@prisma/client';
+import { NextResponse } from 'next/server';
+import { z } from 'zod';
+import { cacheHeaders } from '../../../lib/cache/cacheHeaders';
+import { serializeApiKey } from '../../../lib/apiKeys/serializeApiKey';
+import { getApiKey } from '../../../lib/apiKeys/getApiKey';
+import { getOrganizationApiKey } from '../../../lib/organizationApiKeys/getOrganizationApiKey';
+// ✅ NO imports from @/lib/prisma here!
+// resolvePrisma is loaded lazily only when the handler is called
+export const buildGET = ({ prisma: providedPrisma } = {}) => async () => {
+    // ✅ Lazy import - only runs when handler is called, not at module evaluation
+    const { resolvePrisma } = await import('../../../lib/prisma');
+    const prisma = resolvePrisma(providedPrisma);
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const apiKeys = await prisma.apiKey.findMany({
+        where: {
+            type: ApiKeyType.PUBLIC,
+            workspaceId: privateApiKey.workspaceId,
+        },
+    });
+    return NextResponse.json({
+        apiKeys: apiKeys.map((apiKey) => serializeApiKey({ apiKey })),
+    }, { headers: cacheHeaders });
+};
+export const buildPOST = ({ prisma: providedPrisma } = {}) => async (request) => {
+    // ✅ Lazy import
+    const { resolvePrisma } = await import('../../../lib/prisma');
+    const prisma = resolvePrisma(providedPrisma);
+    const headersList = await headers();
+    const authorization = headersList.get('authorization');
+    if (!authorization) {
+        return NextResponse.json({ error: 'No authorization header found' }, { status: 400 });
+    }
+    const body = await request.json().catch(() => null);
+    const organizationApiKey = await getOrganizationApiKey({
+        authorization,
+        prisma,
+    });
+    if (organizationApiKey) {
+        const createSchemaOrganizationApiKey = z.object({
+            name: z.string().min(1).optional(),
+            type: z.nativeEnum(ApiKeyType),
+            workspaceId: z.string().min(1).optional(),
+        });
+        const parsedOrganizationApiKey = createSchemaOrganizationApiKey.safeParse(body);
+        if (!parsedOrganizationApiKey.success) {
+            return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
+        }
+        const workspace = await prisma.workspace.findUnique({
+            where: {
+                id: parsedOrganizationApiKey.data.workspaceId,
+                organizationId: organizationApiKey.organizationId,
+            },
+        });
+        if (!workspace) {
+            return NextResponse.json({ error: 'Invalid workspace' }, { status: 400 });
+        }
+        const apiKey = await prisma.apiKey.create({
+            data: {
+                type: parsedOrganizationApiKey.data.type,
+                name: parsedOrganizationApiKey.data.name,
+                workspaceId: workspace.id,
+            },
+        });
+        return NextResponse.json({
+            apiKey: serializeApiKey({ apiKey }),
+        }, { headers: cacheHeaders });
+    }
+    const privateApiKey = await getApiKey({
+        type: ApiKeyType.PRIVATE,
+        authorization,
+        prisma,
+    });
+    if (!privateApiKey) {
+        return NextResponse.json({ error: 'Invalid api key' }, { status: 400 });
+    }
+    const createSchema = z.object({
+        name: z.string().min(1).optional(),
+    });
+    const parsed = createSchema.safeParse(body);
+    if (!parsed.success) {
+        return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
+    }
+    const { name } = parsed.data;
+    const workspaceId = privateApiKey.workspaceId;
+    const apiKey = await prisma.apiKey.create({
+        data: {
+            type: ApiKeyType.PUBLIC,
+            name,
+            workspaceId,
+        },
+    });
+    return NextResponse.json({
+        apiKey: serializeApiKey({ apiKey }),
+    }, { headers: cacheHeaders });
+};

package/dist/app/api/api-keys/route.d.ts

@@ -1,10 +1,6 @@
-import { type PrismaClient } from '@prisma/client';
-import { NextResponse } from 'next/server';
-export declare const buildGET: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => () => Promise<NextResponse<{
+export declare const GET: () => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     apiKeys: {
         id: string;
         type: import("@prisma/client").$Enums.ApiKeyType;
@@ -14,12 +10,9 @@ export declare const buildGET: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     }[];
 }>>;
-export declare const GET: ReturnType<typeof buildGET>;
-export declare const buildPOST: ({ prisma: providedPrisma }?: {
-    prisma?: PrismaClient;
-}) => (request: Request) => Promise<NextResponse<{
+export declare const POST: (request: Request) => Promise<import("next/server").NextResponse<{
     error: string;
-}> | NextResponse<{
+}> | import("next/server").NextResponse<{
     apiKey: {
         id: string;
         type: import("@prisma/client").$Enums.ApiKeyType;
@@ -29,6 +22,5 @@ export declare const buildPOST: ({ prisma: providedPrisma }?: {
         updatedAt: string;
     };
 }>>;
-export declare const POST: ReturnType<typeof buildPOST>;
-export declare const OPTIONS: () => NextResponse<{}>;
+export declare const OPTIONS: () => import("next/server").NextResponse<{}>;
 //# sourceMappingURL=route.d.ts.map

package/dist/app/api/api-keys/route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/app/api/api-keys/route.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAQ1C,eAAO,MAAM,QAAQ,GAClB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO;;;;;;;;;;;GAmC1D,CAAA;AAEH,eAAO,MAAM,GAAG,EACU,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAA;AAErD,eAAO,MAAM,SAAS,GACnB,6BAA4B;IAAE,MAAM,CAAC,EAAE,YAAY,CAAA;CAAO,MACpD,SAAS,OAAO;;;;;;;;;;;GAoGtB,CAAA;AAEH,eAAO,MAAM,IAAI,EACU,UAAU,CAAC,OAAO,SAAS,CAAC,CAAA;AAEvD,eAAO,MAAM,OAAO,wBAMjB,CAAA"}
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/app/api/api-keys/route.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG;;;;;;;;;;;GAEd,CAAA;AAEF,eAAO,MAAM,IAAI;;;;;;;;;;;GAEf,CAAA;AAEF,eAAO,MAAM,OAAO,8CAAiB,CAAA"}