fix: cjs interop

Author: nitzano

src/lib/index.ts

@@ -7,16 +7,20 @@ import {
 
 export type PrismaOpenApiSchemaOptions = Partial<PrismaOpenApiOptions>;
 
-export async function generateOpenApiSchema(
+async function generateOpenApiSchema(
 	prismaSchema: string,
 	options: PrismaOpenApiSchemaOptions = {},
 ): Promise<string> {
 	if (!prismaSchema.trim()) {
 		throw new Error('Prisma schema must be a non-empty string.');
 	}
 
+	// Handle CJS/ESM interop - @prisma/internals is CJS, exports may be on .default
+
+	const prismaInternals: any = await import('@prisma/internals');
 	// eslint-disable-next-line @typescript-eslint/naming-convention
-	const {getDMMF} = await import('@prisma/internals');
+	const getDMMF = prismaInternals.default?.getDMMF ?? prismaInternals.getDMMF;
+
 	const dmmf = await getDMMF({datamodel: prismaSchema});
 	const prismaOpenApiOptions: PrismaOpenApiOptions = {
 		...defaultOptions,
@@ -32,19 +36,20 @@ export async function generateOpenApiSchema(
 	);
 
 	if (includeModelsList && includeModelsList.length > 0) {
-		filteredModels = filteredModels.filter((model) =>
-			includeModelsList.includes(model.name),
+		filteredModels = filteredModels.filter((model: any) =>
+			includeModelsList.includes(model.name as string),
 		);
 	}
 
 	if (excludeModelsList && excludeModelsList.length > 0) {
 		filteredModels = filteredModels.filter(
-			(model) => !excludeModelsList.includes(model.name),
+			(model: any) => !excludeModelsList.includes(model.name as string),
 		);
 	}
 
 	const openApiBuilder = generateOpenApiSpec(
 		filteredModels,
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
 		dmmf.datamodel.enums,
 		prismaOpenApiOptions,
 	);
@@ -59,3 +64,10 @@ export async function generateOpenApiSchema(
 
 	return openApiBuilder.getSpecAsJson();
 }
+
+// Named export for ESM consumers
+export {generateOpenApiSchema};
+
+// Default export for CJS interop - handles cases where imports resolve to .default
+const libExports = {generateOpenApiSchema};
+export default libExports;

tests/lib-api.test.ts

@@ -0,0 +1,133 @@
+import {describe, expect, it} from 'vitest';
+import {generateOpenApiSchema} from '../src/lib/index.js';
+
+const simplePrismaSchema = `
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id    Int     @id @default(autoincrement())
+  email String  @unique
+  name  String?
+}
+`;
+
+describe('Library API - generateOpenApiSchema', () => {
+	it('should generate YAML OpenAPI schema by default', async () => {
+		const result = await generateOpenApiSchema(simplePrismaSchema);
+
+		expect(result).toBeDefined();
+		expect(result).toContain('openapi:');
+		expect(result).toContain('User:');
+	});
+
+	it('should generate YAML when generateYaml is true', async () => {
+		const result = await generateOpenApiSchema(simplePrismaSchema, {
+			generateYaml: true,
+		});
+
+		expect(result).toBeDefined();
+		expect(result).toContain('openapi:');
+		expect(result).toContain('User:');
+	});
+
+	it('should generate JSON when generateJson is true', async () => {
+		const result = await generateOpenApiSchema(simplePrismaSchema, {
+			generateJson: true,
+			generateYaml: false,
+		});
+
+		expect(result).toBeDefined();
+		const parsed = JSON.parse(result);
+		expect(parsed.openapi).toBe('3.1.0');
+	});
+
+	it('should throw error for empty schema', async () => {
+		await expect(generateOpenApiSchema('')).rejects.toThrow(
+			'Prisma schema must be a non-empty string.',
+		);
+	});
+
+	it('should throw error for whitespace-only schema', async () => {
+		await expect(generateOpenApiSchema('   \n  ')).rejects.toThrow(
+			'Prisma schema must be a non-empty string.',
+		);
+	});
+
+	it('should respect includeModels option', async () => {
+		const schemaWithMultipleModels = `
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id    Int     @id @default(autoincrement())
+  email String  @unique
+}
+
+model Post {
+  id    Int     @id @default(autoincrement())
+  title String
+}
+`;
+		const result = await generateOpenApiSchema(schemaWithMultipleModels, {
+			includeModels: 'User',
+			generateJson: true,
+			generateYaml: false,
+		});
+
+		const parsed = JSON.parse(result);
+		expect(parsed.components?.schemas?.User).toBeDefined();
+		expect(parsed.components?.schemas?.Post).toBeUndefined();
+	});
+
+	it('should respect excludeModels option', async () => {
+		const schemaWithMultipleModels = `
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id    Int     @id @default(autoincrement())
+  email String  @unique
+}
+
+model Post {
+  id    Int     @id @default(autoincrement())
+  title String
+}
+`;
+		const result = await generateOpenApiSchema(schemaWithMultipleModels, {
+			excludeModels: 'Post',
+			generateJson: true,
+			generateYaml: false,
+		});
+
+		const parsed = JSON.parse(result);
+		expect(parsed.components?.schemas?.User).toBeDefined();
+		expect(parsed.components?.schemas?.Post).toBeUndefined();
+	});
+
+	it('should use custom title when provided', async () => {
+		const result = await generateOpenApiSchema(simplePrismaSchema, {
+			title: 'My Custom API',
+			generateJson: true,
+			generateYaml: false,
+		});
+
+		const parsed = JSON.parse(result);
+		expect(parsed.info?.title).toBe('My Custom API');
+	});
+
+	it('should use custom description when provided', async () => {
+		const result = await generateOpenApiSchema(simplePrismaSchema, {
+			description: 'My API description',
+			generateJson: true,
+			generateYaml: false,
+		});
+
+		const parsed = JSON.parse(result);
+		expect(parsed.info?.description).toBe('My API description');
+	});
+});