prisma-kysely 3.0.0 → 3.1.1

package/dist/shared/chunk-faq6jdwg.js

@@ -0,0 +1,861 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/generator.ts
+import generatorHelper from "@prisma/generator-helper";
+import path3 from "node:path";
+// package.json
+var package_default = {
+  name: "prisma-kysely",
+  version: "3.1.1",
+  description: "Generate Kysely database types from a Prisma schema",
+  repository: {
+    url: "git+https://github.com/valtyr/prisma-kysely.git"
+  },
+  type: "module",
+  license: "MIT",
+  keywords: [
+    "prisma",
+    "kysely",
+    "generator",
+    "typescript",
+    "codegen",
+    "sql"
+  ],
+  author: {
+    name: "Valtyr Orn Kjartansson",
+    url: "http://valtyr.is"
+  },
+  contributors: [
+    {
+      name: "Alistair Smith",
+      url: "https://alistair.sh"
+    },
+    {
+      name: "Arthur Fiorette",
+      url: "https://arthur.place"
+    }
+  ],
+  exports: {
+    ".": "./dist/generator.js",
+    "./generator": "./dist/generator.js",
+    "./bin": "./dist/bin.js"
+  },
+  bin: {
+    "prisma-kysely": "dist/bin.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  scripts: {
+    build: "bunup src/bin.ts src/generator.ts --packages external --format esm --splitting",
+    dev: "bun run build --watch",
+    fix: "prettier --write .",
+    lint: "eslint ./src",
+    prepack: "bun run build",
+    release: "bun run build && bun changeset publish",
+    start: "node dist/bin.js",
+    test: "bun run build && bun test",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    "@mrleebo/prisma-ast": "^0.14.0",
+    "@prisma/generator-helper": "^7.0.0",
+    "@prisma/internals": "^7.0.0",
+    typescript: "^5.9.3",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@changesets/cli": "^2.31.0",
+    "@types/bun": "^1.3.14",
+    "@types/node": "25.3.3",
+    "@types/pg": "^8.20.0",
+    "@types/prettier": "3.0.0",
+    bunup: "^0.16.31",
+    eslint: "^10.4.0",
+    kysely: "^0.28.17",
+    mysql2: "^3.22.3",
+    pg: "^8.21.0",
+    prettier: "^3.8.3",
+    prisma: "^7.8.0",
+    "typescript-eslint": "^8.59.4"
+  },
+  peerDependencies: {
+    prisma: ">=7.0.0"
+  },
+  packageManager: "bun@1.3.14"
+};
+
+// src/constants.ts
+var GENERATOR_NAME = "Kysely types";
+
+// src/helpers/generateDatabaseType.ts
+import ts2 from "typescript";
+
+// src/utils/isValidTSIdentifier.ts
+var isValidTSIdentifier = (ident) => !!ident && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/.test(ident);
+var isValidTSIdentifier_default = isValidTSIdentifier;
+
+// src/utils/words.ts
+function createCamelCaseMapper({
+  upperCase = false
+} = {}) {
+  return memoize((str) => {
+    if (str.length === 0) {
+      return str;
+    }
+    if (upperCase && isAllUpperCaseSnakeCase(str)) {
+      str = str.toLowerCase();
+    }
+    let out = str[0];
+    for (let i = 1, l = str.length;i < l; ++i) {
+      const char = str[i];
+      const prevChar = str[i - 1];
+      if (char !== "_") {
+        if (prevChar === "_") {
+          out += char.toUpperCase();
+        } else {
+          out += char;
+        }
+      }
+    }
+    return out;
+  });
+}
+function isAllUpperCaseSnakeCase(str) {
+  for (let i = 1, l = str.length;i < l; ++i) {
+    const char = str[i];
+    if (char !== "_" && char !== char.toUpperCase()) {
+      return false;
+    }
+  }
+  return true;
+}
+function memoize(func) {
+  const cache = new Map;
+  return (str) => {
+    let mapped = cache.get(str);
+    if (!mapped) {
+      mapped = func(str);
+      cache.set(str, mapped);
+    }
+    return mapped;
+  };
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/utils/normalizeCase.ts
+var snakeToCamel = createCamelCaseMapper();
+var normalizeCase = (name, config) => {
+  if (!config.camelCase)
+    return name;
+  return snakeToCamel(name);
+};
+
+// src/utils/sorted.ts
+var sorted = (list, sortFunction) => {
+  const newList = [...list];
+  newList.sort(sortFunction);
+  return newList;
+};
+
+// src/helpers/wrappedTypeHelpers.ts
+import ts from "typescript";
+var toTableTypeName = (modelName) => `${modelName}Table`;
+var convertToWrappedTypes = (modelDefinition) => {
+  const modelName = modelDefinition.name.text;
+  const tableTypeName = toTableTypeName(modelName);
+  return [
+    { ...modelDefinition, name: ts.factory.createIdentifier(tableTypeName) },
+    ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(modelName), undefined, ts.factory.createTypeReferenceNode("Selectable", [
+      ts.factory.createTypeReferenceNode(tableTypeName, undefined)
+    ])),
+    ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`New${modelName}`), undefined, ts.factory.createTypeReferenceNode("Insertable", [
+      ts.factory.createTypeReferenceNode(tableTypeName, undefined)
+    ])),
+    ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${modelName}Update`), undefined, ts.factory.createTypeReferenceNode("Updateable", [
+      ts.factory.createTypeReferenceNode(tableTypeName, undefined)
+    ]))
+  ];
+};
+
+// src/helpers/generateDatabaseType.ts
+var generateDatabaseType = (models, config) => {
+  const sortedModels = sorted(models, (a, b) => a.tableName.localeCompare(b.tableName));
+  const properties = sortedModels.map((field) => {
+    const caseNormalizedTableName = normalizeCase(field.tableName, config);
+    const nameIdentifier = isValidTSIdentifier_default(caseNormalizedTableName) ? ts2.factory.createIdentifier(caseNormalizedTableName) : ts2.factory.createStringLiteral(caseNormalizedTableName);
+    const typeName = config.exportWrappedTypes ? toTableTypeName(field.typeName) : field.typeName;
+    return ts2.factory.createPropertySignature(undefined, nameIdentifier, undefined, ts2.factory.createTypeReferenceNode(ts2.factory.createIdentifier(typeName), undefined));
+  });
+  return ts2.factory.createTypeAliasDeclaration([ts2.factory.createModifier(ts2.SyntaxKind.ExportKeyword)], ts2.factory.createIdentifier(config.dbTypeName), undefined, ts2.factory.createTypeLiteralNode(properties));
+};
+
+// src/helpers/generateEnumType.ts
+import ts5 from "typescript";
+
+// src/helpers/generateStringLiteralUnion.ts
+import ts3 from "typescript";
+var generateStringLiteralUnion = (stringLiterals) => {
+  if (stringLiterals.length === 0)
+    return null;
+  if (stringLiterals.length === 1)
+    return ts3.factory.createLiteralTypeNode(ts3.factory.createStringLiteral(stringLiterals[0]));
+  return ts3.factory.createUnionTypeNode(stringLiterals.map((literal) => ts3.factory.createLiteralTypeNode(ts3.factory.createStringLiteral(literal))));
+};
+
+// src/helpers/generateTypedReferenceNode.ts
+import ts4 from "typescript";
+var generateTypedReferenceNode = (name) => {
+  return ts4.factory.createTypeAliasDeclaration([ts4.factory.createModifier(ts4.SyntaxKind.ExportKeyword)], name, undefined, ts4.factory.createTypeReferenceNode(`(typeof ${name})[keyof typeof ${name}]`, undefined));
+};
+
+// src/helpers/generateEnumType.ts
+var generateEnumType = (name, values) => {
+  const type = generateStringLiteralUnion(values.map((v) => v.name));
+  if (!type) {
+    return;
+  }
+  const objectDeclaration = ts5.factory.createVariableStatement([ts5.factory.createModifier(ts5.SyntaxKind.ExportKeyword)], ts5.factory.createVariableDeclarationList([
+    ts5.factory.createVariableDeclaration(name, undefined, undefined, ts5.factory.createAsExpression(ts5.factory.createObjectLiteralExpression(values.map((v) => {
+      const identifier = isValidTSIdentifier_default(v.name) ? ts5.factory.createIdentifier(v.name) : ts5.factory.createStringLiteral(v.name);
+      return ts5.factory.createPropertyAssignment(identifier, ts5.factory.createStringLiteral(v.dbName || v.name));
+    }), true), ts5.factory.createTypeReferenceNode(ts5.factory.createIdentifier("const"), undefined)))
+  ], ts5.NodeFlags.Const));
+  const typeDeclaration = generateTypedReferenceNode(name);
+  return {
+    typeName: name,
+    objectDeclaration,
+    typeDeclaration
+  };
+};
+
+// src/helpers/generateFiles.ts
+import path from "node:path";
+import ts7 from "typescript";
+
+// src/helpers/generateFile.ts
+import ts6 from "typescript";
+var printer = ts6.createPrinter({ newLine: ts6.NewLineKind.LineFeed });
+var generateFile = (statements, { withEnumImport, withLeader, exportWrappedTypes, banner }) => {
+  const file = ts6.factory.createSourceFile(statements, ts6.factory.createToken(ts6.SyntaxKind.EndOfFileToken), ts6.NodeFlags.None);
+  const result = printer.printFile(file);
+  const leader = `${banner ? `${banner}
+` : ""}import type { ColumnType${result.includes("GeneratedAlways") ? ", GeneratedAlways" : ""}${exportWrappedTypes ? ", Insertable, Selectable, Updateable" : ""} } from "kysely";
+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>;`;
+  if (withEnumImport) {
+    const enumImportStatement = `import type { ${withEnumImport.names.join(", ")} } from "${withEnumImport.importPath}";`;
+    return withLeader ? `${leader}
+
+${enumImportStatement}
+
+${result}` : `${enumImportStatement}
+
+${result}`;
+  }
+  return withLeader ? `${leader}
+
+${result}` : result;
+};
+
+// src/helpers/generateFiles.ts
+function generateFiles(opts) {
+  const models = opts.models.map(({ definition, ...rest }) => ({
+    ...rest,
+    definitions: opts.exportWrappedTypes ? convertToWrappedTypes(definition) : [definition]
+  }));
+  if (opts.enumsOutfile === opts.typesOutfile || opts.enums.length === 0) {
+    let statements;
+    if (!opts.groupBySchema) {
+      statements = [
+        ...opts.enums.flatMap((e) => [e.objectDeclaration, e.typeDeclaration]),
+        ...models.flatMap((m) => m.definitions)
+      ];
+    } else {
+      statements = groupModelsAndEnum(opts.enums, models, opts.defaultSchema);
+    }
+    const typesFileWithEnums = {
+      filepath: opts.typesOutfile,
+      content: generateFile([...statements, opts.databaseType], {
+        withEnumImport: false,
+        withLeader: true,
+        exportWrappedTypes: opts.exportWrappedTypes,
+        banner: opts.banner
+      })
+    };
+    return [typesFileWithEnums];
+  }
+  const typesFileWithoutEnums = {
+    filepath: opts.typesOutfile,
+    content: generateFile([...models.flatMap((m) => m.definitions), opts.databaseType], {
+      withEnumImport: {
+        importPath: `./${path.parse(opts.enumsOutfile).name}${opts.importExtension}`,
+        names: opts.enumNames
+      },
+      withLeader: true,
+      exportWrappedTypes: opts.exportWrappedTypes,
+      banner: opts.banner
+    })
+  };
+  if (opts.enums.length === 0)
+    return [typesFileWithoutEnums];
+  const enumFile = {
+    filepath: opts.enumsOutfile,
+    content: generateFile(opts.enums.flatMap((e) => [e.objectDeclaration, e.typeDeclaration]), {
+      withEnumImport: false,
+      withLeader: false,
+      exportWrappedTypes: opts.exportWrappedTypes,
+      banner: opts.banner
+    })
+  };
+  return [typesFileWithoutEnums, enumFile];
+}
+function* groupModelsAndEnum(enums, models, defaultSchema) {
+  const groupsMap = new Map;
+  for (const enumType of enums) {
+    if (!enumType.schema || enumType.schema === defaultSchema) {
+      yield enumType.objectDeclaration;
+      yield enumType.typeDeclaration;
+      continue;
+    }
+    const group = groupsMap.get(enumType.schema);
+    if (!group) {
+      groupsMap.set(enumType.schema, [
+        enumType.objectDeclaration,
+        enumType.typeDeclaration
+      ]);
+    } else {
+      group.push(enumType.objectDeclaration, enumType.typeDeclaration);
+    }
+  }
+  for (const model of models) {
+    if (!model.schema || model.schema === defaultSchema) {
+      yield* model.definitions;
+      continue;
+    }
+    const group = groupsMap.get(model.schema);
+    if (!group) {
+      groupsMap.set(model.schema, model.definitions);
+    } else {
+      group.push(...model.definitions);
+    }
+  }
+  for (const [schema, group] of groupsMap) {
+    yield ts7.factory.createModuleDeclaration([ts7.factory.createModifier(ts7.SyntaxKind.ExportKeyword)], ts7.factory.createIdentifier(capitalize(schema)), ts7.factory.createModuleBlock(group), ts7.NodeFlags.Namespace);
+  }
+}
+
+// src/helpers/generateImplicitManyToManyModels.ts
+function generateImplicitManyToManyModels(models) {
+  const manyToManyFields = filterManyToManyRelationFields(models);
+  if (!manyToManyFields.length) {
+    return [];
+  }
+  return generateModels(manyToManyFields, models, []);
+}
+function generateModels(manyToManyFields, models, manyToManyTables = []) {
+  const manyFirst = manyToManyFields.shift();
+  if (!manyFirst) {
+    return manyToManyTables;
+  }
+  const manySecond = manyToManyFields.find((field) => field.relationName === manyFirst.relationName);
+  if (!manySecond) {
+    return manyToManyTables;
+  }
+  manyToManyTables.push({
+    dbName: `_${manyFirst.relationName}`,
+    name: manyFirst.relationName || "",
+    primaryKey: null,
+    schema: null,
+    uniqueFields: [],
+    uniqueIndexes: [],
+    fields: generateJoinFields([manyFirst, manySecond], models)
+  });
+  return generateModels(manyToManyFields.filter((field) => field.relationName !== manyFirst.relationName), models, manyToManyTables);
+}
+function generateJoinFields(fields, models) {
+  if (fields.length !== 2)
+    throw new Error("Huh?");
+  const sortedFields = sorted(fields, (a, b) => a.type.localeCompare(b.type));
+  const joinedA = getJoinIdField(sortedFields[0], models);
+  const joinedB = getJoinIdField(sortedFields[1], models);
+  return [
+    {
+      name: "A",
+      type: joinedA.type,
+      kind: joinedA.kind,
+      isRequired: true,
+      isList: false,
+      isUnique: false,
+      isId: false,
+      isReadOnly: true,
+      hasDefaultValue: false
+    },
+    {
+      name: "B",
+      type: joinedB.type,
+      kind: joinedB.kind,
+      isRequired: true,
+      isList: false,
+      isUnique: false,
+      isId: false,
+      isReadOnly: true,
+      hasDefaultValue: false
+    }
+  ];
+}
+function getJoinIdField(joinField, models) {
+  const joinedModel = models.find((m) => m.name === joinField.type);
+  if (!joinedModel)
+    throw new Error("Could not find referenced model");
+  const idField = joinedModel.fields.find((f) => f.isId);
+  if (!idField)
+    throw new Error("No ID field on referenced model");
+  return idField;
+}
+function filterManyToManyRelationFields(models) {
+  const fields = models.flatMap((model) => model.fields);
+  const relationFields = fields.filter((field) => !!field.relationName);
+  const nonManyToManyRelationNames = relationFields.filter((field) => !field.isList).map((field) => field.relationName);
+  const notManyToMany = new Set(nonManyToManyRelationNames);
+  return relationFields.filter((field) => !notManyToMany.has(field.relationName));
+}
+
+// src/helpers/generateModel.ts
+import ts9 from "typescript";
+
+// src/helpers/generateField.ts
+import ts8 from "typescript";
+
+// src/utils/applyJSDocWorkaround.ts
+var applyJSDocWorkaround = (comment) => {
+  return `*
+ * ${comment.split(`
+`).join(`
+ * `)}
+ `;
+};
+
+// src/helpers/generateField.ts
+var generateField = (args) => {
+  const { name, type, nullable, generated, list, documentation, isId, config } = args;
+  let fieldType = type;
+  if (nullable)
+    fieldType = ts8.factory.createUnionTypeNode([
+      fieldType,
+      ts8.factory.createLiteralTypeNode(ts8.factory.createToken(ts8.SyntaxKind.NullKeyword))
+    ]);
+  if (list)
+    fieldType = ts8.factory.createArrayTypeNode(fieldType);
+  if (generated) {
+    if (isId && config.readOnlyIds) {
+      fieldType = ts8.factory.createTypeReferenceNode(ts8.factory.createIdentifier("GeneratedAlways"), [fieldType]);
+    } else {
+      fieldType = ts8.factory.createTypeReferenceNode(ts8.factory.createIdentifier("Generated"), [fieldType]);
+    }
+  }
+  const nameIdentifier = isValidTSIdentifier_default(name) ? ts8.factory.createIdentifier(name) : ts8.factory.createStringLiteral(name);
+  const propertySignature = ts8.factory.createPropertySignature(undefined, nameIdentifier, undefined, fieldType);
+  if (documentation) {
+    return ts8.addSyntheticLeadingComment(propertySignature, ts8.SyntaxKind.MultiLineCommentTrivia, applyJSDocWorkaround(documentation), true);
+  }
+  return propertySignature;
+};
+
+// src/helpers/generateFieldType.ts
+var sqliteTypeMap = {
+  BigInt: "number",
+  Boolean: "number",
+  Bytes: "Buffer",
+  DateTime: "string",
+  Decimal: "number",
+  Float: "number",
+  Int: "number",
+  Json: "unknown",
+  String: "string",
+  Unsupported: "unknown"
+};
+var mysqlTypeMap = {
+  BigInt: "number",
+  Boolean: "number",
+  Bytes: "Buffer",
+  DateTime: "Timestamp",
+  Decimal: "string",
+  Float: "number",
+  Int: "number",
+  Json: "unknown",
+  String: "string",
+  Unsupported: "unknown"
+};
+var postgresqlTypeMap = {
+  BigInt: "string",
+  Boolean: "boolean",
+  Bytes: "Buffer",
+  DateTime: "Timestamp",
+  Decimal: "string",
+  Float: "number",
+  Int: "number",
+  Json: "unknown",
+  String: "string",
+  Unsupported: "unknown"
+};
+var sqlServerTypeMap = {
+  BigInt: "number",
+  Boolean: "boolean",
+  Bytes: "Buffer",
+  DateTime: "Timestamp",
+  Decimal: "string",
+  Float: "number",
+  Int: "number",
+  Json: "unknown",
+  String: "string",
+  Unsupported: "unknown"
+};
+var overrideType = (type, config) => {
+  switch (type) {
+    case "String":
+      return config.stringTypeOverride;
+    case "DateTime":
+      return config.dateTimeTypeOverride;
+    case "Boolean":
+      return config.booleanTypeOverride;
+    case "BigInt":
+      return config.bigIntTypeOverride;
+    case "Int":
+      return config.intTypeOverride;
+    case "Float":
+      return config.floatTypeOverride;
+    case "Decimal":
+      return config.decimalTypeOverride;
+    case "Bytes":
+      return config.bytesTypeOverride;
+    case "Json":
+      return config.jsonTypeOverride;
+    case "Unsupported":
+      return config.unsupportedTypeOverride;
+  }
+};
+var generateFieldTypeInner = (type, config, typeOverride) => {
+  switch (config.databaseProvider) {
+    case "sqlite":
+      return typeOverride || overrideType(type, config) || sqliteTypeMap[type];
+    case "mysql":
+      return typeOverride || overrideType(type, config) || mysqlTypeMap[type];
+    case "postgresql":
+      return typeOverride || overrideType(type, config) || postgresqlTypeMap[type];
+    case "cockroachdb":
+      return typeOverride || overrideType(type, config) || postgresqlTypeMap[type];
+    case "sqlserver":
+      return typeOverride || overrideType(type, config) || sqlServerTypeMap[type];
+  }
+};
+var generateFieldType = (type, config, typeOverride) => {
+  const fieldType = generateFieldTypeInner(type, config, typeOverride || null);
+  if (!fieldType)
+    throw new Error(`Unsupported type ${type} for database ${config.databaseProvider}`);
+  return fieldType;
+};
+
+// src/helpers/generateTypeOverrideFromDocumentation.ts
+var START_LEXEME = "@kyselyType(";
+var generateTypeOverrideFromDocumentation = (documentation) => {
+  const tokens = documentation.split("");
+  let matchState = null;
+  let parentheses = 0;
+  let i = 0;
+  while (i < documentation.length) {
+    const currentToken = tokens[i];
+    if (matchState) {
+      if (currentToken === ")" && parentheses === 0)
+        return matchState.tokens.join("");
+      if (currentToken === ")")
+        parentheses--;
+      if (currentToken === "(")
+        parentheses++;
+      matchState.tokens.push(currentToken);
+      i++;
+      if (i === documentation.length) {
+        i = matchState.startLocation + 1;
+        matchState = null;
+        continue;
+      }
+      continue;
+    }
+    if (currentToken === "@") {
+      const isMatch = tokens.slice(i, i + START_LEXEME.length).join("") === START_LEXEME;
+      if (!isMatch) {
+        i++;
+        continue;
+      }
+      matchState = { tokens: [], startLocation: i };
+      i += START_LEXEME.length;
+      continue;
+    }
+    i++;
+  }
+  return null;
+};
+
+// src/helpers/generateModel.ts
+var defaultTypesImplementedInJS = ["cuid", "uuid"];
+var generateModel = (model, config, { defaultSchema, groupBySchema, multiSchemaMap }) => {
+  const properties = model.fields.flatMap((field) => {
+    const isGenerated = field.hasDefaultValue && !(typeof field.default === "object" && ("name" in field.default) && defaultTypesImplementedInJS.includes(field.default.name));
+    const typeOverride = field.documentation ? generateTypeOverrideFromDocumentation(field.documentation) : null;
+    if (field.kind === "object" || field.kind === "unsupported")
+      return [];
+    const dbName = typeof field.dbName === "string" ? field.dbName : null;
+    const schemaPrefix = groupBySchema && multiSchemaMap?.get(field.type);
+    if (field.kind === "enum") {
+      const isEnumArray = field.isList;
+      return generateField({
+        isId: field.isId,
+        name: normalizeCase(dbName || field.name, config),
+        type: isEnumArray ? ts9.factory.createKeywordTypeNode(ts9.SyntaxKind.StringKeyword) : ts9.factory.createTypeReferenceNode(ts9.factory.createIdentifier(schemaPrefix && defaultSchema !== schemaPrefix ? `${capitalize(schemaPrefix)}.${field.type}` : field.type), undefined),
+        nullable: !field.isRequired,
+        generated: isGenerated,
+        list: false,
+        documentation: field.documentation,
+        config
+      });
+    }
+    return generateField({
+      name: normalizeCase(dbName || field.name, config),
+      type: ts9.factory.createTypeReferenceNode(ts9.factory.createIdentifier(generateFieldType(field.type, config, typeOverride)), undefined),
+      nullable: !field.isRequired,
+      generated: isGenerated,
+      list: field.isList,
+      documentation: field.documentation,
+      isId: field.isId,
+      config
+    });
+  });
+  return {
+    typeName: model.name,
+    tableName: model.dbName || model.name,
+    definition: ts9.factory.createTypeAliasDeclaration([ts9.factory.createModifier(ts9.SyntaxKind.ExportKeyword)], ts9.factory.createIdentifier(model.name), undefined, ts9.factory.createTypeLiteralNode(properties))
+  };
+};
+
+// src/helpers/multiSchemaHelpers.ts
+import { getSchema } from "@mrleebo/prisma-ast";
+import ts10 from "typescript";
+var convertToMultiSchemaModels = ({
+  defaultSchema,
+  filterBySchema,
+  groupBySchema,
+  models,
+  multiSchemaMap
+}) => {
+  return models.flatMap((model) => {
+    const schemaName = multiSchemaMap?.get(model.typeName);
+    if (!schemaName) {
+      return model;
+    }
+    if (filterBySchema && !filterBySchema.has(schemaName)) {
+      return [];
+    }
+    if (schemaName === defaultSchema) {
+      return model;
+    }
+    return [
+      {
+        ...model,
+        typeName: groupBySchema ? `${capitalize(schemaName)}.${model.typeName}` : model.typeName,
+        tableName: model.tableName ? `${schemaName}.${model.tableName}` : undefined,
+        schema: groupBySchema ? schemaName : undefined
+      }
+    ];
+  });
+};
+var isIdentifierText = ts10.isIdentifierText;
+function parseMultiSchemaMap(dataModelStr) {
+  const parsedSchema = getSchema(dataModelStr);
+  const multiSchemaMap = new Map;
+  for (const block of parsedSchema.list) {
+    if (block.type !== "model" && block.type !== "view" && block.type !== "type" && block.type !== "enum") {
+      continue;
+    }
+    const properties = block.type === "enum" ? block.enumerators : block.properties;
+    const schemaProperty = properties.find((prop) => prop.type === "attribute" && prop.name === "schema");
+    const schemaName = schemaProperty?.args?.[0].value;
+    if (typeof schemaName !== "string") {
+      multiSchemaMap.set(block.name, "");
+    } else {
+      const schema = JSON.parse(schemaName).toString();
+      if (isIdentifierText && !isIdentifierText(schema)) {
+        throw new Error(`Cannot generate identifier for schema "${schema}" in model "${block.name}" because it is not a valid Identifier, please disable \`groupBySchema\` or rename it.`);
+      }
+      multiSchemaMap.set(block.name, schema);
+    }
+  }
+  return multiSchemaMap;
+}
+
+// src/utils/validateConfig.ts
+import prismaInternals from "@prisma/internals";
+import z from "zod";
+var { logger } = prismaInternals;
+var booleanStringLiteral = z.union([z.boolean(), z.literal("true"), z.literal("false")]).transform((arg) => {
+  if (typeof arg === "boolean")
+    return arg;
+  return arg === "true";
+});
+var configValidator = z.object({
+  databaseProvider: z.union([
+    z.literal("postgresql"),
+    z.literal("cockroachdb"),
+    z.literal("mysql"),
+    z.literal("sqlite"),
+    z.literal("sqlserver")
+  ]),
+  fileName: z.string().optional().default("types.ts"),
+  importExtension: z.string().default(""),
+  enumFileName: z.string().optional(),
+  stringTypeOverride: z.string().optional(),
+  booleanTypeOverride: z.string().optional(),
+  intTypeOverride: z.string().optional(),
+  bigIntTypeOverride: z.string().optional(),
+  floatTypeOverride: z.string().optional(),
+  decimalTypeOverride: z.string().optional(),
+  dateTimeTypeOverride: z.string().optional(),
+  jsonTypeOverride: z.string().optional(),
+  bytesTypeOverride: z.string().optional(),
+  unsupportedTypeOverride: z.string().optional(),
+  dbTypeName: z.string().default("DB"),
+  camelCase: booleanStringLiteral.default(false),
+  readOnlyIds: booleanStringLiteral.default(false),
+  groupBySchema: booleanStringLiteral.default(false),
+  defaultSchema: z.string().default("public"),
+  filterBySchema: z.array(z.string()).optional(),
+  exportWrappedTypes: booleanStringLiteral.default(false),
+  banner: z.string().optional()
+}).strict().transform((config) => {
+  if (!config.enumFileName) {
+    config.enumFileName = config.fileName;
+  }
+  if (config.groupBySchema && config.enumFileName !== config.fileName) {
+    throw new Error("groupBySchema is not compatible with enumFileName");
+  }
+  return config;
+});
+var validateConfig = (config) => {
+  const parsed = configValidator.safeParse(config);
+  if (!parsed.success) {
+    logger.error("Invalid prisma-kysely config");
+    Object.entries(parsed.error.flatten().fieldErrors).forEach(([key, value]) => {
+      logger.error(`${key}: ${value.join(", ")}`);
+    });
+    Object.values(parsed.error.flatten().formErrors).forEach((value) => {
+      logger.error(`${value}`);
+    });
+    process.exit(1);
+  }
+  return parsed.data;
+};
+
+// src/utils/writeFileSafely.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/utils/formatFile.ts
+var formatFile = async (content) => {
+  try {
+    const { default: prettier } = await import("prettier");
+    const config = await prettier.resolveConfig(process.cwd());
+    if (!config)
+      return content;
+    const formatted = prettier.format(content, {
+      ...config,
+      parser: "typescript"
+    });
+    return formatted;
+  } catch {}
+  return content;
+};
+
+// src/utils/writeFileSafely.ts
+var writeFileSafely = async (writeLocation, content) => {
+  fs.mkdirSync(path2.dirname(writeLocation), {
+    recursive: true
+  });
+  fs.writeFileSync(writeLocation, await formatFile(content));
+};
+
+// src/generator.ts
+var { version } = package_default;
+var { generatorHandler } = generatorHelper;
+generatorHandler({
+  onManifest() {
+    return {
+      version,
+      defaultOutput: "./generated",
+      prettyName: GENERATOR_NAME
+    };
+  },
+  onGenerate: async (options) => {
+    if (!options.version) {
+      throw new Error(`Could not determine Prisma version. ` + `Make sure you are using a recent version of Prisma.`);
+    }
+    const semverMatch = options.version.match(/^(\d+)\./);
+    if (semverMatch && parseInt(semverMatch[1], 10) < 7) {
+      throw new Error(`prisma-kysely v${version} requires Prisma 7 or later. ` + `You are using Prisma ${options.version}. ` + `Please upgrade Prisma or use prisma-kysely v2.x for Prisma 6.`);
+    }
+    const config = validateConfig({
+      ...options.generator.config,
+      databaseProvider: options.datasources[0].provider
+    });
+    let enums = options.dmmf.datamodel.enums.map(({ name, values }) => generateEnumType(name, values)).filter((e) => !!e);
+    const implicitManyToManyModels = generateImplicitManyToManyModels(options.dmmf.datamodel.models);
+    const hasMultiSchema = options.datasources.some((d) => d.schemas.length > 0);
+    const multiSchemaMap = config.groupBySchema || hasMultiSchema ? parseMultiSchemaMap(options.datamodel) : undefined;
+    let models = sorted([...options.dmmf.datamodel.models, ...implicitManyToManyModels], (a, b) => a.name.localeCompare(b.name)).map((m) => generateModel(m, config, {
+      groupBySchema: config.groupBySchema,
+      defaultSchema: config.defaultSchema,
+      multiSchemaMap
+    }));
+    if (hasMultiSchema) {
+      const filterBySchema = config.filterBySchema ? new Set(config.filterBySchema) : null;
+      models = convertToMultiSchemaModels({
+        models,
+        groupBySchema: config.groupBySchema,
+        defaultSchema: config.defaultSchema,
+        filterBySchema,
+        multiSchemaMap
+      });
+      enums = convertToMultiSchemaModels({
+        models: enums,
+        groupBySchema: config.groupBySchema,
+        defaultSchema: config.defaultSchema,
+        filterBySchema,
+        multiSchemaMap
+      });
+    }
+    const databaseType = generateDatabaseType(models, config);
+    const files = generateFiles({
+      databaseType,
+      enumNames: options.dmmf.datamodel.enums.map((e) => e.name),
+      models,
+      enums,
+      enumsOutfile: config.enumFileName,
+      typesOutfile: config.fileName,
+      groupBySchema: config.groupBySchema,
+      defaultSchema: config.defaultSchema,
+      importExtension: config.importExtension,
+      exportWrappedTypes: config.exportWrappedTypes,
+      banner: config.banner
+    });
+    await Promise.allSettled(files.map(({ filepath, content }) => {
+      const writeLocation = path3.join(options.generator.output?.value || "", filepath);
+      return writeFileSafely(writeLocation, content);
+    }));
+  }
+});