Export enums and related types like Prisma does (#38)

* Export enums and related types like Prisma does

* Update test name to better reflect the test

* Add changeset

* Append `as const` to enum objects

* Fix tests after adding `as const`

* Update changeset

---------

Co-authored-by: Valtýr Örn Kjartansson <valtyr@gmail.com>

.changeset/ten-fans-vanish.md

@@ -0,0 +1,5 @@
+---
+"prisma-kysely": patch
+---
+
+Now using narrower types for enum objects bringing `prisma-kysely`'s enums in line with `prisma-client-js` (Thank you @jvandenaardweg 🎉)

src/__test__/e2e.test.ts

@@ -101,12 +101,12 @@ test(
     const enumFile = await fs.readFile("./prisma/generated/enums.ts", {
       encoding: "utf-8",
     });
-    expect(enumFile).toEqual(`export type TestEnum = "A" | "B" | "C";
-export const TestEnum = {
+    expect(enumFile).toEqual(`export const TestEnum = {
   A: "A",
   B: "B",
   C: "C",
-};
+} as const;
+export type TestEnum = (typeof TestEnum)[keyof typeof TestEnum];
 `);
   },
   { timeout: 20000 }

src/helpers/generateEnumType.test.ts

@@ -0,0 +1,25 @@
+import ts, { createPrinter } from "typescript";
+import { expect, test } from "vitest";
+
+import { generateEnumType } from "./generateEnumType";
+
+test("it generates the enum type", () => {
+  const [objectDeclaration, typeDeclaration] = generateEnumType("Name", [
+    { name: "FOO", dbName: "FOO" },
+    { name: "BAR", dbName: "BAR" },
+  ]);
+
+  const printer = createPrinter();
+
+  const result = printer.printList(
+    ts.ListFormat.MultiLine,
+    ts.factory.createNodeArray([objectDeclaration, typeDeclaration]),
+    ts.createSourceFile("", "", ts.ScriptTarget.Latest)
+  );
+
+  expect(result).toEqual(`export const Name = {
+    FOO: "FOO",
+    BAR: "BAR"
+} as const;
+export type Name = (typeof Name)[keyof typeof Name];\n`);
+});

src/helpers/generateEnumType.ts

@@ -4,7 +4,7 @@ import ts from "typescript";
 import isValidTSIdentifier from "~/utils/isValidTSIdentifier";
 
 import { generateStringLiteralUnion } from "./generateStringLiteralUnion";
-import { generateTypedAliasDeclaration } from "./generateTypedAliasDeclaration";
+import { generateTypedReferenceNode } from "./generateTypedReferenceNode";
 
 export const generateEnumType = (name: string, values: DMMF.EnumValue[]) => {
   const type = generateStringLiteralUnion(values.map((v) => v.name));
@@ -19,26 +19,33 @@ export const generateEnumType = (name: string, values: DMMF.EnumValue[]) => {
           name,
           undefined,
           undefined,
-          ts.factory.createObjectLiteralExpression(
-            values.map((v) => {
-              const identifier = isValidTSIdentifier(v.name)
-                ? ts.factory.createIdentifier(v.name)
-                : ts.factory.createStringLiteral(v.name);
-
-              return ts.factory.createPropertyAssignment(
-                identifier,
-                ts.factory.createStringLiteral(v.name)
-              );
-            }),
-            true
+
+          ts.factory.createAsExpression(
+            ts.factory.createObjectLiteralExpression(
+              values.map((v) => {
+                const identifier = isValidTSIdentifier(v.name)
+                  ? ts.factory.createIdentifier(v.name)
+                  : ts.factory.createStringLiteral(v.name);
+
+                return ts.factory.createPropertyAssignment(
+                  identifier,
+                  ts.factory.createStringLiteral(v.name)
+                );
+              }),
+              true
+            ),
+            ts.factory.createTypeReferenceNode(
+              ts.factory.createIdentifier("const"),
+              undefined
+            )
           )
         ),
       ],
       ts.NodeFlags.Const
     )
   );
 
-  const typeDeclaration = generateTypedAliasDeclaration(name, type);
+  const typeDeclaration = generateTypedReferenceNode(name);
 
-  return [typeDeclaration, objectDeclaration];
+  return [objectDeclaration, typeDeclaration];
 };

src/helpers/generateTypedReferenceNode.test.ts

@@ -0,0 +1,15 @@
+import { expect, test } from "vitest";
+
+import { stringifyTsNode } from "~/utils/testUtils";
+
+import { generateTypedReferenceNode } from "./generateTypedReferenceNode";
+
+test("it generated the typed reference node", () => {
+  const node = generateTypedReferenceNode("Name");
+
+  const result = stringifyTsNode(node);
+
+  expect(result).toEqual(
+    "export type Name = (typeof Name)[keyof typeof Name];"
+  );
+});

src/helpers/generateTypedReferenceNode.ts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+
+export const generateTypedReferenceNode = (name: string) => {
+  return ts.factory.createTypeAliasDeclaration(
+    undefined,
+    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+    name,
+    undefined,
+    ts.factory.createTypeReferenceNode(
+      `(typeof ${name})[keyof typeof ${name}]`,
+      undefined
+    )
+  );
+};