refactor: rename additionalImports to filePrefix

vargaadam · vargaadam · commit 2d28b35db8c8 · 2025-10-20T15:05:35.000+02:00
diff --git a/README.md b/README.md
@@ -39,28 +39,28 @@ without losing the safety of the TypeScript type system?
        fileName = "types.ts"
        // Optionally generate runtime enums to a separate file
        enumFileName = "enums.ts"
-       // Optionally include a custom import section (single or multi-line)
-       additionalImports = "import Decimal from 'decimal.js';"
+       // Optionally add content at the start of generated files (imports, pragmas, comments, etc.)
+       filePrefix = "import type { Decimal } from 'decimal.js';"
        // For multi-line, use Prisma's triple-quoted string syntax (see below)
    }
    ```
 
 3. Run `prisma migrate dev` or `prisma generate` and use your freshly generated
    types when instantiating Kysely!
 
-### Advanced Import Configuration
+### File Prefix Configuration
 
-The `additionalImports` option supports full import sections, allowing you to import multiple libraries with different syntaxes:
+The `filePrefix` option allows you to add custom content at the start of generated files. This is particularly useful for importing custom types and libraries:
 
 ```prisma
 generator kysely {
     provider = "prisma-kysely"
     output = "../src/db"
     fileName = "types.ts"
 
-    // Import multiple libraries with different syntaxes
-    additionalImports = """
-import Decimal from 'decimal.js';
+    // Add custom imports for libraries you need in generated types
+    filePrefix = """
+import type { Decimal } from 'decimal.js';
 import { Big } from 'big.js';
 import * as moment from 'moment';
 import { v4 as uuid } from 'uuid';
@@ -72,14 +72,13 @@ import type { SomeType } from './custom-types';
 This will generate a file that starts with:
 
 ```typescript
-import { Big } from "big.js";
-import Decimal from "decimal.js";
-import type { ColumnType } from "kysely";
-import * as moment from "moment";
-import { v4 as uuid } from "uuid";
-
-import type { SomeType } from "./custom-types";
+import type { Decimal } from 'decimal.js';
+import { Big } from 'big.js';
+import * as moment from 'moment';
+import { v4 as uuid } from 'uuid';
+import type { SomeType } from './custom-types';
 
+import type { ColumnType } from "kysely";
 // ... rest of generated types
 ```
 
@@ -119,7 +118,7 @@ hope it's just as useful for you! 😎
 | `enumFileName`           | The filename for the generated enums. Omitting this will generate enums and files in the same file.                                                                                                                                                                                                                                                                                 |            |
 | `camelCase`              | Enable support for Kysely's camelCase plugin                                                                                                                                                                                                                                                                                                                                        | `false`    |
 | `exportWrappedTypes`     | Kysely wrapped types such as `Selectable<Model>` are also exported as described in the [Kysely documentation](https://kysely.dev/docs/getting-started#types). The exported types follow the naming conventions of the document.                                                                                                                                                     | `false`    |
-| `additionalImports`      | A full import section to prepend to the generated file. Supports any TS import syntax (default, named, namespace, renamed, and `import type`). Single-line strings or multi-line via Prisma triple-quoted strings (`""" ... """`). The content is inserted verbatim; no sorting or deduplication is performed.                                                                      |            |
+| `filePrefix`             | Content to prepend to the start of generated file(s). Useful for custom imports, pragma directives (e.g., `// @ts-nocheck`), comments, or any other content. Supports single-line strings or multi-line via Prisma triple-quoted strings (`""" ... """`). The content is inserted verbatim at the top of the file(s).                                                               |            |
 | `readOnlyIds`            | Use Kysely's `GeneratedAlways` for `@id` fields with default values, preventing insert and update.                                                                                                                                                                                                                                                                                  | `false`    |
 | `[typename]TypeOverride` | Allows you to override the resulting TypeScript type for any Prisma type. Useful when targeting a different environment than Node (e.g. WinterCG compatible runtimes that use UInt8Arrays instead of Buffers for binary types etc.) Check out the [config validator](https://github.com/valtyr/prisma-kysely/blob/main/src/utils/validateConfig.ts) for a complete list of options. |            |
 | `dbTypeName`             | Allows you to override the exported type with all tables                                                                                                                                                                                                                                                                                                                            | `DB`       |
diff --git a/src/generator.ts b/src/generator.ts
@@ -107,7 +107,7 @@ generatorHandler({
       defaultSchema: config.defaultSchema,
       importExtension: config.importExtension,
       exportWrappedTypes: config.exportWrappedTypes,
-      additionalImports: config.additionalImports,
+      filePrefix: config.filePrefix,
     });
 
     // And write it to a file!
diff --git a/src/helpers/generateFile.test.ts b/src/helpers/generateFile.test.ts
@@ -37,22 +37,22 @@ test("generates a file which imports Kysely wrapper types.", () => {
   );
 });
 
-test("generates a file with single additional import when additionalImports is specified.", () => {
+test("generates a file with custom prefix when filePrefix is specified.", () => {
   const result = generateFile([], {
     withEnumImport: false,
     withLeader: true,
     exportWrappedTypes: false,
-    additionalImports: "import Decimal from 'decimal.js';",
+    filePrefix: "import Decimal from 'decimal.js';",
   });
   expect(result).toContain("import Decimal from 'decimal.js';");
 });
 
-test("generates a file with multiple additional imports when additionalImports is specified.", () => {
+test("generates a file with multiple imports in filePrefix.", () => {
   const result = generateFile([], {
     withEnumImport: false,
     withLeader: true,
     exportWrappedTypes: false,
-    additionalImports: `import Decimal from 'decimal.js';
+    filePrefix: `import Decimal from 'decimal.js';
 import { Big } from 'big.js';
 import * as moment from 'moment';`,
   });
@@ -61,12 +61,12 @@ import * as moment from 'moment';`,
   expect(result).toContain("import * as moment from 'moment';");
 });
 
-test("generates a file with named additional import when additionalImports is specified.", () => {
+test("generates a file with filePrefix containing renamed imports.", () => {
   const result = generateFile([], {
     withEnumImport: false,
     withLeader: true,
     exportWrappedTypes: false,
-    additionalImports: "import { v4 as uuid } from 'uuid';",
+    filePrefix: "import { v4 as uuid } from 'uuid';",
   });
   expect(result).toContain("import { v4 as uuid } from 'uuid';");
 });
diff --git a/src/helpers/generateFile.ts b/src/helpers/generateFile.ts
@@ -6,12 +6,12 @@ type Options = {
   withEnumImport: false | { importPath: string; names: string[] };
   withLeader: boolean;
   exportWrappedTypes: boolean;
-  additionalImports?: string;
+  filePrefix?: string;
 };
 
 export const generateFile = (
   statements: readonly ts.Statement[],
-  { withEnumImport, withLeader, exportWrappedTypes, additionalImports }: Options
+  { withEnumImport, withLeader, exportWrappedTypes, filePrefix }: Options
 ) => {
   const file = ts.factory.createSourceFile(
     statements,
@@ -21,7 +21,7 @@ export const generateFile = (
 
   const result = printer.printFile(file);
 
-  const leader = `${additionalImports ? `${additionalImports}\n` : ""}import type { ColumnType${
+  const leader = `${filePrefix ? `${filePrefix}\n` : ""}import type { ColumnType${
     result.includes("GeneratedAlways") ? ", GeneratedAlways" : ""
   }${
     exportWrappedTypes ? ", Insertable, Selectable, Updateable" : ""
diff --git a/src/helpers/generateFiles.ts b/src/helpers/generateFiles.ts
@@ -25,7 +25,7 @@ export function generateFiles(opts: {
   defaultSchema: string;
   importExtension: string;
   exportWrappedTypes: boolean;
-  additionalImports?: string;
+  filePrefix?: string;
 }) {
   const models = opts.models.map(
     ({ definition, ...rest }: ModelType): MultiDefsModelType => ({
@@ -55,7 +55,7 @@ export function generateFiles(opts: {
         withEnumImport: false,
         withLeader: true,
         exportWrappedTypes: opts.exportWrappedTypes,
-        additionalImports: opts.additionalImports,
+        filePrefix: opts.filePrefix,
       }),
     };
 
@@ -73,7 +73,7 @@ export function generateFiles(opts: {
         },
         withLeader: true,
         exportWrappedTypes: opts.exportWrappedTypes,
-        additionalImports: opts.additionalImports,
+        filePrefix: opts.filePrefix,
       }
     ),
   };
@@ -88,7 +88,7 @@ export function generateFiles(opts: {
         withEnumImport: false,
         withLeader: false,
         exportWrappedTypes: opts.exportWrappedTypes,
-        additionalImports: opts.additionalImports,
+        filePrefix: opts.filePrefix,
       }
     ),
   };
diff --git a/src/utils/validateConfig.ts b/src/utils/validateConfig.ts
@@ -57,8 +57,8 @@ export const configValidator = z
     // Export Kysely wrapped types such as `Selectable<Model>`
     exportWrappedTypes: booleanStringLiteral.default(false),
 
-    // Import any additional libraries. Set to the full import section you want (e.g., "import Decimal from 'decimal.js';", "import { Big } from 'big.js';", multiple imports separated by newlines, etc.)
-    additionalImports: z.string().optional(),
+    // Content to prepend to the start of the generated file(s). Useful for custom imports, pragmas, or comments.
+    filePrefix: z.string().optional(),
   })
   .strict()
   .transform((config) => {
