List enum values should be typed as strings

.changeset/angry-rivers-fail.md

@@ -0,0 +1,5 @@
+---
+"prisma-kysely": minor
+---
+
+Make enum array values actually be strings

package.json

@@ -63,5 +63,6 @@
     ],
     "importOrderSeparation": true,
     "importOrderSortSpecifiers": true
-  }
+  },
+  "packageManager": "[email protected]+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
 }

src/__test__/e2e.test.ts

@@ -29,21 +29,27 @@ test(
     await fs.writeFile(
       "./prisma/schema.prisma",
       `datasource db {
-        provider = "sqlite"
-        url      = "file:./dev.db"
+        provider = "postgresql"
+        url      = "env(DATABASE_URL)"
     }
 
     generator kysely {
         provider  = "node ./dist/bin.js"
     }
 
+    enum TestEnum {
+      FOO
+      BAR
+    }
+
     model TestUser {
         id          String @id
         name        String
         age         Int
         rating      Float
         updatedAt   DateTime
         sprockets   Sprocket[]
+        abc         TestEnum[]
     }
 
     model Sprocket {
@@ -66,6 +72,9 @@ test(
   B: string;
 };`)
     ).toBeTruthy();
+
+    expect(generatedSource.includes(`abc: EnumArray<TestEnum>;`)).toBeTruthy();
+
     expect(
       generatedSource.includes("_SprocketToTestUser: SprocketToTestUser")
     ).toBeTruthy();
@@ -164,8 +173,10 @@ test(
     const typeFile = await fs.readFile("./prisma/generated/types.ts", {
       encoding: "utf-8",
     });
+
     expect(typeFile).not.toContain("export const");
     expect(typeFile).toContain(`import type { TestEnum } from "./enums";`);
+    expect(typeFile.includes(`abc: TestEnum`)).toBeTruthy();
 
     const enumFile = await fs.readFile("./prisma/generated/enums.ts", {
       encoding: "utf-8",

src/helpers/generateFile.ts

@@ -25,7 +25,9 @@ export const generateFile = (
 export type Generated<T> = T extends ColumnType<infer S, infer I, infer U>
   ? ColumnType<S, I | undefined, U>
   : ColumnType<T, T | undefined, T>;
-export type Timestamp = ColumnType<Date, Date | string, Date | string>;`;
+export type Timestamp = ColumnType<Date, Date | string, Date | string>;
+export type EnumArrayInner<T extends string, All extends string> = T extends infer Single extends string ? T | \`\${Single},\${Exclude<All, Single>}\` : never
+export type EnumArray<T extends string> = '{}' | \`{\${EnumArrayInner<T, T>}}\`;`;
 
   if (withEnumImport) {
     const enumImportStatement = `import type { ${withEnumImport.names.join(

src/helpers/generateModel.test.ts

@@ -165,3 +165,42 @@ test("it respects camelCase option", () => {
     userName: string | null;
 };`);
 });
+
+test("it respects enum array values", () => {
+  const model = generateModel(
+    {
+      name: "User",
+      fields: [
+        {
+          name: "permissions",
+          isId: false,
+          isGenerated: false,
+          kind: "enum",
+          type: "UserPermissions",
+          hasDefaultValue: false,
+          isList: true,
+          isReadOnly: false,
+          isRequired: true,
+          isUnique: false,
+        },
+      ],
+      primaryKey: null,
+      uniqueFields: [],
+      uniqueIndexes: [],
+      dbName: null,
+    },
+    {
+      databaseProvider: "postgresql",
+      fileName: "env(DATABASE_URL)",
+      enumFileName: "",
+      camelCase: true,
+      readOnlyIds: false,
+    }
+  );
+
+  const source = stringifyTsNode(model.definition);
+
+  expect(source).toEqual(`export type User = {
+    permissions: EnumArray<UserPermissions>;
+};`);
+});

src/helpers/generateModel.ts

@@ -33,16 +33,29 @@ export const generateModel = (model: DMMF.Model, config: Config) => {
     const dbName = typeof field.dbName === "string" ? field.dbName : null;
 
     if (field.kind === "enum") {
+      const type = field.isList
+        ? ts.factory.createTypeReferenceNode(
+            ts.factory.createIdentifier("EnumArray"),
+            [
+              ts.factory.createTypeReferenceNode(
+                ts.factory.createIdentifier(field.type),
+                undefined
+              ),
+            ]
+          )
+        : ts.factory.createTypeReferenceNode(
+            ts.factory.createIdentifier(field.type),
+            undefined
+          );
+
       return generateField({
         isId: field.isId,
         name: normalizeCase(dbName || field.name, config),
-        type: ts.factory.createTypeReferenceNode(
-          ts.factory.createIdentifier(field.type),
-          undefined
-        ),
+        type,
         nullable: !field.isRequired,
         generated: isGenerated,
-        list: field.isList,
+        // Enum list values are handled as strings, so we don't need to wrap them in a list
+        list: false,
         documentation: field.documentation,
         config,
       });