hekireki 0.10.1 โ†’ 0.10.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -24,6 +24,7 @@
24
24
  - ๐Ÿ—„๏ธ Automatically generates [Drizzle ORM](https://orm.drizzle.team/) table schemas and relations from your Prisma schema
25
25
  - ๐ŸŸ Automatically generates [Kysely](https://kysely.dev/) type definitions (`DB` interface) from your Prisma schema โ€” with database-side-only `Generated` columns, enum value unions, `@map`/`@@map` support, and implicit m2m join tables
26
26
  - ๐Ÿ Automatically generates [SQLAlchemy](https://www.sqlalchemy.org/) models (Python) โ€” with `Mapped[T]` type hints, relationships, enums, composite keys, and index support
27
+ - ๐ŸŽธ Automatically generates [Django ORM](https://www.djangoproject.com/) models (Python, Django โ‰ฅ 5.2) โ€” with `ForeignKey` / `OneToOneField` / `ManyToManyField` relations (`related_name` from the Prisma back-relation), `TextChoices` enums, composite primary keys (`CompositePrimaryKey`), migration-serializable defaults, `db_default` for `now()` / `dbgenerated(...)`, and `Meta` constraints / indexes
27
28
  - ๐Ÿน Automatically generates [GORM](https://gorm.io/) models (Go) โ€” with struct tags, JSON tags, relationships, enums, composite keys, and index support
28
29
  - ๐Ÿฆ€ Automatically generates [Sea-ORM](https://www.sea-ql.org/SeaORM/) entities (Rust) โ€” with `DeriveEntityModel`, relations, enums, serde support, and `rename_all`
29
30
  - ๐Ÿงช Generates [Ecto](https://hexdocs.pm/ecto/Ecto.Schema.html) schemas (Elixir) โ€” with associations (`belongs_to`, `has_many`, `has_one`), composite primary keys, `@type t` typespecs, array fields, `@@map`/`@map` support, and `@moduledoc`
@@ -125,6 +126,11 @@ generator Hekireki-SQLAlchemy {
125
126
  output = "./sqlalchemy"
126
127
  }
127
128
 
129
+ generator Hekireki-Django {
130
+ provider = "hekireki-django"
131
+ output = "./django"
132
+ }
133
+
128
134
  generator Hekireki-GORM {
129
135
  provider = "hekireki-gorm"
130
136
  output = "./gorm"
@@ -908,6 +914,52 @@ class Post(Base):
908
914
  user: Mapped["User"] = relationship(back_populates="posts")
909
915
  ```
910
916
 
917
+ ### Django
918
+
919
+ [Django ORM](https://www.djangoproject.com/) models (Python, Django โ‰ฅ 5.2). The foreign-key scalar and its relation field collapse into a single `ForeignKey` (a unique FK becomes `OneToOneField`, an implicit m2m becomes `ManyToManyField` plus an explicit through model over Prisma's `_Join` table), `related_name` comes from the Prisma back-relation, and Prisma's implicit referential actions apply when none is given (`RESTRICT` for required, `SET_NULL` for optional). Enums become `TextChoices` storing the `@map`-ped values, composite `@@id` becomes `CompositePrimaryKey`, `@default(now())` / `dbgenerated(...)` become `db_default`, `@updatedAt` becomes `auto_now=True`, and every generated default is migration-serializable (module-level helper functions, never lambdas).
920
+
921
+ ```python
922
+ import uuid
923
+
924
+ from django.db import models
925
+
926
+
927
+ def uuid4_str() -> str:
928
+ return str(uuid.uuid4())
929
+
930
+
931
+ class User(models.Model):
932
+ id = models.TextField(primary_key=True, default=uuid4_str)
933
+ name = models.TextField()
934
+
935
+ class Meta:
936
+ db_table = "user"
937
+
938
+
939
+ class Post(models.Model):
940
+ id = models.TextField(primary_key=True, default=uuid4_str)
941
+ title = models.TextField()
942
+ content = models.TextField()
943
+ user = models.ForeignKey("User", on_delete=models.RESTRICT, related_name="posts", db_index=False)
944
+
945
+ class Meta:
946
+ db_table = "post"
947
+ ```
948
+
949
+ Names follow the same rule as the other ORM generators: a table or column is `@@map` / `@map` when given, otherwise the `snake_case` of the Prisma name. Prisma itself leaves an unmapped name verbatim (`Profile`, `accountId`), so **map every model and field whose Prisma name is not already `snake_case`** if the models are to run against a database Prisma created. Attribute names stay `snake_case` for PEP 8 either way, with `db_column` carrying the real column.
950
+
951
+ Things Django cannot express, and what is emitted instead:
952
+
953
+ | Prisma | Django | Why |
954
+ | ------------------------------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
955
+ | A foreign key to a composite `@@unique` or `@@id` | The scalar columns, no relation | `CompositePrimaryKey` cannot be a `ForeignKey` target, and a half-join on one column would be wrong |
956
+ | `enum` | `TextChoices` + `TextField(choices=โ€ฆ)` | Django has no native PostgreSQL enum type. Reads work through the implicit cast; `OPTIONS={"server_side_binding": True}` and `__startswith`-style lookups on an enum column do not |
957
+ | `@id @default(cuid())` / `nanoid()` | `TextField(primary_key=True, default=None)` | No generator is emitted, so the value must be assigned. `None` is what makes an unassigned one raise on INSERT instead of overwriting the row whose key is `""` |
958
+ | `onUpdate` | dropped | Django models referential actions in Python and has no `onUpdate` concept |
959
+ | Plain `DateTime` | `DateTimeField` | Prisma maps it to `timestamp` (no zone) while Django expects `timestamptz`; annotate it `@db.Timestamptz` to keep `USE_TZ = True` reads aware |
960
+
961
+ The models are written for a database Prisma owns, so they are read and written through, not migrated from. `makemigrations` still runs, but its DDL differs from Prisma's: Django writes no `ON DELETE` clause (it cascades in Python), marks foreign keys `DEFERRABLE INITIALLY DEFERRED`, and adds a `text_pattern_ops` companion index beside every text primary key and unique column.
962
+
911
963
  ### Pydantic
912
964
 
913
965
  [Pydantic](https://docs.pydantic.dev/) v2 models (Python). `@p.` field annotations are used verbatim as the base type โ€” list fields wrap it in `list[...]` and optional fields append `| None = None` โ€” and imports for the known pydantic / typing names they reference (`EmailStr`, `Annotated`, `StringConstraints`, โ€ฆ) are added automatically; names outside that set are emitted as-is without an import. Fields without an annotation fall back to the built-in Prisma โ†’ Python type mapping, enums become `Literal[...]` of their Prisma-level value names, and relation fields are omitted.
@@ -1208,6 +1260,12 @@ generator Hekireki-SQLAlchemy {
1208
1260
  output = "./sqlalchemy" // Required. A directory here yields ./sqlalchemy/models.py
1209
1261
  }
1210
1262
 
1263
+ // Django Generator (Python, Django >= 5.2)
1264
+ generator Hekireki-Django {
1265
+ provider = "hekireki-django"
1266
+ output = "./django" // Required. A directory here yields ./django/models.py
1267
+ }
1268
+
1211
1269
  // Pydantic Generator (Python)
1212
1270
  generator Hekireki-Pydantic {
1213
1271
  provider = "hekireki-pydantic"
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/activerecord.ts
4
4
  registerGenerator("activerecord");
5
5
  //#endregion
package/dist/bin/ajv.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/ajv.ts
4
4
  registerGenerator("ajv");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/arktype.ts
4
4
  registerGenerator("arktype");
5
5
  //#endregion
package/dist/bin/atlas.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/atlas.ts
4
4
  registerGenerator("atlas");
5
5
  //#endregion
package/dist/bin/dbml.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/dbml.ts
4
4
  registerGenerator("dbml");
5
5
  //#endregion
@@ -0,0 +1 @@
1
+ export {}
@@ -0,0 +1,6 @@
1
+ #!/usr/bin/env node
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
+ //#region src/bin/django.ts
4
+ registerGenerator("django");
5
+ //#endregion
6
+ export {};
package/dist/bin/docs.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/docs.ts
4
4
  registerGenerator("docs");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/drizzle.ts
4
4
  registerGenerator("drizzle");
5
5
  //#endregion
package/dist/bin/ecto.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/ecto.ts
4
4
  registerGenerator("ecto");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/effect.ts
4
4
  registerGenerator("effect");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/eloquent.ts
4
4
  registerGenerator("eloquent");
5
5
  //#endregion
package/dist/bin/gorm.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/gorm.ts
4
4
  registerGenerator("gorm");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/kysely.ts
4
4
  registerGenerator("kysely");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/mermaid-er.ts
4
4
  registerGenerator("mermaid-er");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/pydantic.ts
4
4
  registerGenerator("pydantic");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/sea-orm.ts
4
4
  registerGenerator("sea-orm");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/sqlalchemy.ts
4
4
  registerGenerator("sqlalchemy");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/typebox.ts
4
4
  registerGenerator("typebox");
5
5
  //#endregion
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/valibot.ts
4
4
  registerGenerator("valibot");
5
5
  //#endregion
package/dist/bin/zod.js CHANGED
@@ -1,5 +1,5 @@
1
1
  #!/usr/bin/env node
2
- import { t as registerGenerator } from "../bin-CR9GrJIk.js";
2
+ import { t as registerGenerator } from "../bin-9aHkP_Bs.js";
3
3
  //#region src/bin/zod.ts
4
4
  registerGenerator("zod");
5
5
  //#endregion
@@ -686,7 +686,7 @@ function tableRef(target, models, defaultSchema) {
686
686
  const name = tableNameOf(target);
687
687
  return duplicateTableNames(models).has(name) ? `table${refPart(schemaOf(target, defaultSchema))}${refPart(name)}` : `table${refPart(name)}`;
688
688
  }
689
- function isFunctionDefault$5(def) {
689
+ function isFunctionDefault$6(def) {
690
690
  return def !== null && typeof def === "object" && !Array.isArray(def) && "name" in def;
691
691
  }
692
692
  function pgNativeType$1(name, args) {
@@ -932,7 +932,7 @@ function listDefault(items, field, dialect, enums) {
932
932
  function resolveDefault(field, dialect, enums) {
933
933
  const dflt = field.default;
934
934
  if (!field.hasDefaultValue || dflt === void 0 || dflt === null) return void 0;
935
- if (isFunctionDefault$5(dflt)) {
935
+ if (isFunctionDefault$6(dflt)) {
936
936
  if (dflt.name === "now") return dialect === "mysql" ? sqlExpr("CURRENT_TIMESTAMP(3)") : sqlExpr("CURRENT_TIMESTAMP");
937
937
  if (dflt.name === "dbgenerated") return typeof dflt.args[0] === "string" ? sqlExpr(dflt.args[0]) : void 0;
938
938
  return;
@@ -947,7 +947,7 @@ function resolveDefault(field, dialect, enums) {
947
947
  }
948
948
  function makeAtlasColumn(field, dialect, enums, comment) {
949
949
  const name = field.dbName ?? field.name;
950
- const isAutoincrement = isFunctionDefault$5(field.default) && field.default.name === "autoincrement";
950
+ const isAutoincrement = isFunctionDefault$6(field.default) && field.default.name === "autoincrement";
951
951
  const typeInfo = columnTypeInfo(field, dialect, enums, isAutoincrement);
952
952
  const defaultValue = isAutoincrement ? void 0 : resolveDefault(field, dialect, enums);
953
953
  const doc = comment ? stripAnnotations(field.documentation) : void 0;
@@ -1291,11 +1291,11 @@ function makePrismaColumn(column) {
1291
1291
  ].filter((c) => Boolean(c));
1292
1292
  return ` ${column.name} ${column.type}${formatConstraints(constraints)}`;
1293
1293
  }
1294
- function isFunctionDefault$4(def) {
1294
+ function isFunctionDefault$5(def) {
1295
1295
  return def !== null && typeof def === "object" && "name" in def;
1296
1296
  }
1297
1297
  function toDBMLColumn(field, models, mapToDbSchema) {
1298
- const defaultName = isFunctionDefault$4(field.default) ? field.default.name : void 0;
1298
+ const defaultName = isFunctionDefault$5(field.default) ? field.default.name : void 0;
1299
1299
  const baseType = mapToDbSchema ? models.find((m) => m.name === field.type)?.dbName ?? field.type : field.type;
1300
1300
  const type = field.isList && !field.relationName ? `${baseType}[]` : baseType;
1301
1301
  const defaultValue = (() => {
@@ -1391,7 +1391,8 @@ function dbmlContent(datamodel, mapToDbSchema = false) {
1391
1391
  ].join("\n\n");
1392
1392
  }
1393
1393
  function dbmlToPng(dbml) {
1394
- return new Resvg(run(dbml, "svg"), { font: { loadSystemFonts: true } }).render().asPng();
1394
+ const svg = run(dbml, "svg");
1395
+ return new Resvg(svg, { font: { loadSystemFonts: true } }).render().asPng();
1395
1396
  }
1396
1397
  //#endregion
1397
1398
  //#region src/core/dbml.ts
@@ -1411,6 +1412,702 @@ async function dbml(options) {
1411
1412
  return emitRaw(outPath.endsWith(".png") ? dbmlToPng(content) : content, path.dirname(outPath), outPath);
1412
1413
  }
1413
1414
  //#endregion
1415
+ //#region src/helper/django.ts
1416
+ const PRISMA_TO_DJANGO = {
1417
+ String: "TextField",
1418
+ Int: "IntegerField",
1419
+ BigInt: "BigIntegerField",
1420
+ Float: "FloatField",
1421
+ Decimal: "DecimalField",
1422
+ Boolean: "BooleanField",
1423
+ DateTime: "DateTimeField",
1424
+ Json: "JSONField",
1425
+ Bytes: "BinaryField"
1426
+ };
1427
+ const PRISMA_TO_PYTHON$1 = {
1428
+ String: "str",
1429
+ Int: "int",
1430
+ BigInt: "int",
1431
+ Float: "float",
1432
+ Decimal: "Decimal",
1433
+ Boolean: "bool",
1434
+ DateTime: "datetime",
1435
+ Json: "Any",
1436
+ Bytes: "bytes"
1437
+ };
1438
+ function prismaTypeToDjangoField(type) {
1439
+ return PRISMA_TO_DJANGO[type] ?? "TextField";
1440
+ }
1441
+ const PYTHON_KEYWORDS$2 = /* @__PURE__ */ new Set([
1442
+ "False",
1443
+ "None",
1444
+ "True",
1445
+ "and",
1446
+ "as",
1447
+ "assert",
1448
+ "async",
1449
+ "await",
1450
+ "break",
1451
+ "class",
1452
+ "continue",
1453
+ "def",
1454
+ "del",
1455
+ "elif",
1456
+ "else",
1457
+ "except",
1458
+ "finally",
1459
+ "for",
1460
+ "from",
1461
+ "global",
1462
+ "if",
1463
+ "import",
1464
+ "in",
1465
+ "is",
1466
+ "lambda",
1467
+ "nonlocal",
1468
+ "not",
1469
+ "or",
1470
+ "pass",
1471
+ "raise",
1472
+ "return",
1473
+ "try",
1474
+ "while",
1475
+ "with",
1476
+ "yield"
1477
+ ]);
1478
+ const DJANGO_RESERVED = /* @__PURE__ */ new Set([
1479
+ "pk",
1480
+ "self",
1481
+ "cls",
1482
+ "objects"
1483
+ ]);
1484
+ function acceptableAttrName(columnName) {
1485
+ const collapsed = columnName.replaceAll(/_{2,}/gu, "_");
1486
+ return collapsed.endsWith("_") ? `${collapsed}field` : collapsed;
1487
+ }
1488
+ function djangoAttrName(columnName) {
1489
+ const name = acceptableAttrName(columnName);
1490
+ return PYTHON_KEYWORDS$2.has(name) || DJANGO_RESERVED.has(name) ? `${name}_field` : name;
1491
+ }
1492
+ const CHOICES_RESERVED = /* @__PURE__ */ new Set([
1493
+ "choices",
1494
+ "labels",
1495
+ "values",
1496
+ "names",
1497
+ "mro"
1498
+ ]);
1499
+ function enumMemberName(valueName) {
1500
+ return PYTHON_KEYWORDS$2.has(valueName) || CHOICES_RESERVED.has(valueName) ? `${valueName}_` : valueName;
1501
+ }
1502
+ function resolveDjangoField(field) {
1503
+ const base = prismaTypeToDjangoField(field.type);
1504
+ const baseResolved = base === "DecimalField" ? {
1505
+ ctor: base,
1506
+ typeArgs: ["max_digits=65", "decimal_places=30"]
1507
+ } : {
1508
+ ctor: base,
1509
+ typeArgs: []
1510
+ };
1511
+ if (!field.nativeType) return baseResolved;
1512
+ const [nativeName, nativeArgs] = field.nativeType;
1513
+ const args = nativeArgs ?? [];
1514
+ switch (nativeName) {
1515
+ case "VarChar":
1516
+ case "Char": return args.length > 0 ? {
1517
+ ctor: "CharField",
1518
+ typeArgs: [`max_length=${args[0]}`]
1519
+ } : {
1520
+ ctor: "TextField",
1521
+ typeArgs: []
1522
+ };
1523
+ case "Text":
1524
+ case "TinyText":
1525
+ case "MediumText":
1526
+ case "LongText":
1527
+ case "Citext":
1528
+ case "Xml":
1529
+ case "Bit":
1530
+ case "VarBit": return {
1531
+ ctor: "TextField",
1532
+ typeArgs: []
1533
+ };
1534
+ case "SmallInt":
1535
+ case "TinyInt": return {
1536
+ ctor: "SmallIntegerField",
1537
+ typeArgs: []
1538
+ };
1539
+ case "MediumInt":
1540
+ case "Integer":
1541
+ case "Oid": return {
1542
+ ctor: "IntegerField",
1543
+ typeArgs: []
1544
+ };
1545
+ case "BigInt": return {
1546
+ ctor: "BigIntegerField",
1547
+ typeArgs: []
1548
+ };
1549
+ case "Real":
1550
+ case "DoublePrecision":
1551
+ case "Double": return {
1552
+ ctor: "FloatField",
1553
+ typeArgs: []
1554
+ };
1555
+ case "Decimal":
1556
+ case "Money": return args.length >= 2 ? {
1557
+ ctor: "DecimalField",
1558
+ typeArgs: [`max_digits=${args[0]}`, `decimal_places=${args[1]}`]
1559
+ } : {
1560
+ ctor: "DecimalField",
1561
+ typeArgs: ["max_digits=65", "decimal_places=30"]
1562
+ };
1563
+ case "Uuid": return {
1564
+ ctor: "UUIDField",
1565
+ typeArgs: []
1566
+ };
1567
+ case "Date": return {
1568
+ ctor: "DateField",
1569
+ typeArgs: []
1570
+ };
1571
+ case "Time":
1572
+ case "Timetz": return {
1573
+ ctor: "TimeField",
1574
+ typeArgs: []
1575
+ };
1576
+ case "Timestamp":
1577
+ case "Timestamptz": return {
1578
+ ctor: "DateTimeField",
1579
+ typeArgs: []
1580
+ };
1581
+ case "Json":
1582
+ case "JsonB": return {
1583
+ ctor: "JSONField",
1584
+ typeArgs: []
1585
+ };
1586
+ case "ByteA": return {
1587
+ ctor: "BinaryField",
1588
+ typeArgs: []
1589
+ };
1590
+ case "Inet": return {
1591
+ ctor: "GenericIPAddressField",
1592
+ typeArgs: []
1593
+ };
1594
+ case "Boolean": return {
1595
+ ctor: "BooleanField",
1596
+ typeArgs: []
1597
+ };
1598
+ default: return baseResolved;
1599
+ }
1600
+ }
1601
+ function toPythonString$1(value) {
1602
+ return `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r")}"`;
1603
+ }
1604
+ function jsonToPythonLiteral$1(value) {
1605
+ if (value === null) return "None";
1606
+ if (value === true) return "True";
1607
+ if (value === false) return "False";
1608
+ if (typeof value === "number") return String(value);
1609
+ if (typeof value === "string") return toPythonString$1(value);
1610
+ if (Array.isArray(value)) return `[${value.map(jsonToPythonLiteral$1).join(", ")}]`;
1611
+ if (typeof value === "object") return `{${Object.entries(value).map(([k, v]) => `${toPythonString$1(k)}: ${jsonToPythonLiteral$1(v)}`).join(", ")}}`;
1612
+ return "None";
1613
+ }
1614
+ function isFunctionDefault$4(def) {
1615
+ return def !== null && typeof def === "object" && "name" in def && !Array.isArray(def);
1616
+ }
1617
+ function isAutoincrement$3(field) {
1618
+ return isFunctionDefault$4(field.default) && field.default.name === "autoincrement";
1619
+ }
1620
+ function uuidDefaultVersion$1(field) {
1621
+ if (!(isFunctionDefault$4(field.default) && field.default.name === "uuid")) return null;
1622
+ return field.default.args[0] === 7 ? 7 : 4;
1623
+ }
1624
+ function isUlidDefault$1(field) {
1625
+ return isFunctionDefault$4(field.default) && field.default.name === "ulid";
1626
+ }
1627
+ function isNowDefault(field) {
1628
+ return field.type === "DateTime" && isFunctionDefault$4(field.default) && field.default.name === "now";
1629
+ }
1630
+ function dbGeneratedExpr(field) {
1631
+ return isFunctionDefault$4(field.default) && field.default.name === "dbgenerated" && typeof field.default.args[0] === "string" ? field.default.args[0] : null;
1632
+ }
1633
+ function scalarElementLiteral(type, value) {
1634
+ if (typeof value === "boolean") return value ? "True" : "False";
1635
+ if (typeof value === "number") return type === "Decimal" ? `Decimal("${value}")` : String(value);
1636
+ if (typeof value === "string") {
1637
+ if (type === "BigInt") return value;
1638
+ if (type === "Decimal") return `Decimal("${value}")`;
1639
+ if (type === "DateTime") return `datetime.fromisoformat(${toPythonString$1(value)})`;
1640
+ if (type === "Json") return jsonToPythonLiteral$1(JSON.parse(value));
1641
+ return toPythonString$1(value);
1642
+ }
1643
+ return jsonToPythonLiteral$1(value);
1644
+ }
1645
+ function fieldColumnName(field) {
1646
+ return field.dbName ?? makeSnakeCase(field.name);
1647
+ }
1648
+ function nameKey(modelName, fieldName) {
1649
+ return `${modelName}.${fieldName}`;
1650
+ }
1651
+ function claimName(preferred, taken) {
1652
+ const name = (taken.has(preferred) ? Array.from({ length: taken.size + 1 }, (_, i) => `${preferred}_${i + 2}`).find((candidate) => !taken.has(candidate)) : preferred) ?? preferred;
1653
+ taken.add(name);
1654
+ return name;
1655
+ }
1656
+ function modelAttrNames(model, m2mTables) {
1657
+ const belongsTo = singleColumnBelongsTo(model);
1658
+ const fkByScalarName = new Map(belongsTo.map((f) => [f.relationFromFields?.[0], f]));
1659
+ const taken = /* @__PURE__ */ new Set(["pk"]);
1660
+ const names = /* @__PURE__ */ new Map();
1661
+ for (const field of model.fields) {
1662
+ if (field.kind === "object") {
1663
+ if (field.isList && isDeclaringM2MSide(model, field, m2mTables)) names.set(field.name, claimName(djangoAttrName(makeSnakeCase(field.name)), taken));
1664
+ continue;
1665
+ }
1666
+ const owner = fkByScalarName.get(field.name);
1667
+ if (owner) {
1668
+ const attr = claimName(djangoAttrName(makeSnakeCase(owner.name)), taken);
1669
+ names.set(owner.name, attr);
1670
+ names.set(field.name, attr);
1671
+ continue;
1672
+ }
1673
+ names.set(field.name, claimName(djangoAttrName(fieldColumnName(field)), taken));
1674
+ }
1675
+ return names;
1676
+ }
1677
+ function resolveNames(models, m2mTables = []) {
1678
+ const attr = /* @__PURE__ */ new Map();
1679
+ for (const model of models) for (const [fieldName, attrName] of modelAttrNames(model, m2mTables)) attr.set(nameKey(model.name, fieldName), attrName);
1680
+ const takenHelpers = /* @__PURE__ */ new Set([
1681
+ "uuid4_str",
1682
+ "uuid7_str",
1683
+ "ulid_str"
1684
+ ]);
1685
+ const helper = /* @__PURE__ */ new Map();
1686
+ for (const model of models) for (const field of model.fields) {
1687
+ if (field.kind === "object") continue;
1688
+ const attrName = attr.get(nameKey(model.name, field.name)) ?? makeSnakeCase(field.name);
1689
+ helper.set(nameKey(model.name, field.name), claimName(`${makeSnakeCase(model.name)}_${attrName}_default`, takenHelpers));
1690
+ }
1691
+ return {
1692
+ attr,
1693
+ helper
1694
+ };
1695
+ }
1696
+ function attrNameOf(names, model, field) {
1697
+ return names.attr.get(nameKey(model.name, field.name)) ?? djangoAttrName(fieldColumnName(field));
1698
+ }
1699
+ function helperNameOf(names, model, field) {
1700
+ return names.helper.get(nameKey(model.name, field.name)) ?? `${makeSnakeCase(model.name)}_${djangoAttrName(fieldColumnName(field))}_default`;
1701
+ }
1702
+ function fieldDefaultHelper(model, field, names, enumMap) {
1703
+ const helperName = helperNameOf(names, model, field);
1704
+ if (field.isList && Array.isArray(field.default) && field.default.length > 0) {
1705
+ const enumDef = field.kind === "enum" ? enumMap.get(field.type) : void 0;
1706
+ const pythonType = field.kind === "enum" ? "str" : PRISMA_TO_PYTHON$1[field.type] ?? "str";
1707
+ const items = field.default.map((v) => enumDef && typeof v === "string" ? `${makePascalCase(field.type)}.${enumMemberName(v)}` : scalarElementLiteral(field.type, v)).join(", ");
1708
+ return [`def ${helperName}() -> list[${pythonType}]:`, ` return [${items}]`].join("\n");
1709
+ }
1710
+ if (field.type === "Json" && typeof field.default === "string") {
1711
+ const parsed = JSON.parse(field.default);
1712
+ if (typeof parsed === "object" && parsed !== null) {
1713
+ if (Array.isArray(parsed) ? parsed.length === 0 : Object.keys(parsed).length === 0) return null;
1714
+ return [`def ${helperName}() -> ${Array.isArray(parsed) ? "list[Any]" : "dict[str, Any]"}:`, ` return ${jsonToPythonLiteral$1(parsed)}`].join("\n");
1715
+ }
1716
+ return [`def ${helperName}() -> ${jsonScalarReturnType(parsed)}:`, ` return ${jsonToPythonLiteral$1(parsed)}`].join("\n");
1717
+ }
1718
+ return null;
1719
+ }
1720
+ function pythonBytesLiteral(base64) {
1721
+ return `b"${[...Buffer.from(base64, "base64")].map((byte) => `\\x${byte.toString(16).padStart(2, "0")}`).join("")}"`;
1722
+ }
1723
+ function jsonScalarReturnType(parsed) {
1724
+ if (typeof parsed === "string") return "str";
1725
+ if (typeof parsed === "boolean") return "bool";
1726
+ if (typeof parsed === "number") return Number.isInteger(parsed) ? "int" : "float";
1727
+ return "None";
1728
+ }
1729
+ function collectDefaultHelpers(models, names, enums) {
1730
+ const enumMap = new Map((enums ?? []).map((e) => [e.name, e]));
1731
+ const uuidHelpers = [
1732
+ models.some((m) => m.fields.some((f) => uuidDefaultVersion$1(f) === 4 && f.nativeType?.[0] !== "Uuid")) ? ["def uuid4_str() -> str:", " return str(uuid.uuid4())"].join("\n") : null,
1733
+ models.some((m) => m.fields.some((f) => uuidDefaultVersion$1(f) === 7 && f.nativeType?.[0] !== "Uuid")) ? ["def uuid7_str() -> str:", " return str(uuid6.uuid7())"].join("\n") : null,
1734
+ models.some((m) => m.fields.some((f) => isUlidDefault$1(f))) ? ["def ulid_str() -> str:", " return str(ULID())"].join("\n") : null
1735
+ ].filter((h) => h !== null);
1736
+ const fieldHelpers = models.flatMap((model) => model.fields.filter((f) => f.kind !== "object").map((field) => fieldDefaultHelper(model, field, names, enumMap)).filter((h) => h !== null));
1737
+ return [...uuidHelpers, ...fieldHelpers];
1738
+ }
1739
+ function formatDefaultArgs(model, field, isPk, names) {
1740
+ if (field.isUpdatedAt) return ["auto_now=True"];
1741
+ const generated = dbGeneratedExpr(field);
1742
+ if (generated !== null) return [`db_default=RawSQL(${toPythonString$1(generated)}, [])`];
1743
+ if (isNowDefault(field)) return ["db_default=Now()"];
1744
+ const uuidVersion = uuidDefaultVersion$1(field);
1745
+ if (uuidVersion !== null) {
1746
+ if (field.nativeType?.[0] === "Uuid") return [uuidVersion === 7 ? "default=uuid6.uuid7" : "default=uuid.uuid4"];
1747
+ return [uuidVersion === 7 ? "default=uuid7_str" : "default=uuid4_str"];
1748
+ }
1749
+ if (isUlidDefault$1(field)) return ["default=ulid_str"];
1750
+ const def = field.default;
1751
+ if (def === void 0 || def === null) return [];
1752
+ if (isFunctionDefault$4(def)) return [];
1753
+ if (Array.isArray(def)) return def.length === 0 ? ["default=list"] : [`default=${helperNameOf(names, model, field)}`];
1754
+ if (field.kind === "enum" && typeof def === "string") return [`default=${makePascalCase(field.type)}.${enumMemberName(def)}`];
1755
+ if (isPk) return [];
1756
+ if (typeof def === "boolean") return [def ? "default=True" : "default=False"];
1757
+ if (typeof def === "number") return field.type === "Decimal" ? [`default=Decimal("${def}")`] : [`default=${def}`];
1758
+ if (typeof def === "string") {
1759
+ if (field.type === "BigInt") return [`default=${def}`];
1760
+ if (field.type === "Decimal") return [`default=Decimal("${def}")`];
1761
+ if (field.type === "DateTime") return [`default=datetime.fromisoformat(${toPythonString$1(def)})`];
1762
+ if (field.type === "Bytes") return [`default=${pythonBytesLiteral(def)}`];
1763
+ if (field.type === "Json") {
1764
+ const parsed = JSON.parse(def);
1765
+ if (typeof parsed === "object" && parsed !== null) {
1766
+ if (Array.isArray(parsed) ? parsed.length === 0 : Object.keys(parsed).length === 0) return [Array.isArray(parsed) ? "default=list" : "default=dict"];
1767
+ }
1768
+ return [`default=${helperNameOf(names, model, field)}`];
1769
+ }
1770
+ return [`default=${toPythonString$1(def)}`];
1771
+ }
1772
+ return [];
1773
+ }
1774
+ function autoFieldCtor(field) {
1775
+ if (field.nativeType?.[0] === "SmallInt") return "SmallAutoField";
1776
+ return field.type === "BigInt" ? "BigAutoField" : "AutoField";
1777
+ }
1778
+ function generateScalarField(model, field, isPk, names) {
1779
+ const columnName = fieldColumnName(field);
1780
+ const attrName = attrNameOf(names, model, field);
1781
+ const resolved = field.kind === "enum" ? {
1782
+ ctor: "TextField",
1783
+ typeArgs: [`choices=${makePascalCase(field.type)}.choices`]
1784
+ } : resolveDjangoField(field);
1785
+ const ctorResolved = isPk && isAutoincrement$3(field) ? {
1786
+ ctor: autoFieldCtor(field),
1787
+ typeArgs: []
1788
+ } : resolved;
1789
+ const defaultArgs = formatDefaultArgs(model, field, isPk, names);
1790
+ const emptyStringPk = isPk && defaultArgs.length === 0 && [
1791
+ "TextField",
1792
+ "CharField",
1793
+ "BinaryField"
1794
+ ].includes(ctorResolved.ctor);
1795
+ const outerArgs = [
1796
+ isPk ? "primary_key=True" : null,
1797
+ !field.isList && !field.isRequired ? "null=True" : null,
1798
+ field.isUnique ? "unique=True" : null,
1799
+ attrName !== columnName ? `db_column=${toPythonString$1(columnName)}` : null,
1800
+ ...defaultArgs,
1801
+ emptyStringPk ? "default=None" : null
1802
+ ].filter((a) => a !== null);
1803
+ if (field.isList) return ` ${attrName} = ArrayField(${[`models.${ctorResolved.ctor}(${ctorResolved.typeArgs.join(", ")})`, ...outerArgs].join(", ")})`;
1804
+ return ` ${attrName} = models.${ctorResolved.ctor}(${[...ctorResolved.typeArgs, ...outerArgs].join(", ")})`;
1805
+ }
1806
+ const ON_DELETE = {
1807
+ Cascade: "models.CASCADE",
1808
+ SetNull: "models.SET_NULL",
1809
+ Restrict: "models.RESTRICT",
1810
+ NoAction: "models.DO_NOTHING",
1811
+ SetDefault: "models.SET_DEFAULT"
1812
+ };
1813
+ function onDeleteFor(field) {
1814
+ if (field.relationOnDelete && ON_DELETE[field.relationOnDelete]) return ON_DELETE[field.relationOnDelete];
1815
+ return field.isRequired ? "models.RESTRICT" : "models.SET_NULL";
1816
+ }
1817
+ function findBackRelationField(relationField, model, allModels) {
1818
+ const targetModel = allModels.find((m) => m.name === relationField.type);
1819
+ return targetModel?.fields.find((f) => f.kind === "object" && f.type === model.name && f.relationName === relationField.relationName && !(targetModel.name === model.name && f.name === relationField.name));
1820
+ }
1821
+ function generateForeignKeyField(model, relationField, scalarField, allModels, names) {
1822
+ const attrName = attrNameOf(names, model, relationField);
1823
+ const columnName = fieldColumnName(scalarField);
1824
+ const backField = findBackRelationField(relationField, model, allModels);
1825
+ const ctor = backField && !backField.isList ? "OneToOneField" : "ForeignKey";
1826
+ const target = relationField.type === model.name ? "\"self\"" : `"${makePascalCase(relationField.type)}"`;
1827
+ const relatedName = backField ? toPythonString$1(djangoAttrName(makeSnakeCase(backField.name))) : "\"+\"";
1828
+ const targetModel = allModels.find((m) => m.name === relationField.type);
1829
+ const referencedName = relationField.relationToFields?.[0];
1830
+ const referencedField = targetModel?.fields.find((f) => f.name === referencedName);
1831
+ const toField = referencedField && !referencedField.isId && targetModel ? `to_field=${toPythonString$1(attrNameOf(names, targetModel, referencedField))}` : null;
1832
+ return ` ${attrName} = models.${ctor}(${[
1833
+ target,
1834
+ `on_delete=${onDeleteFor(relationField)}`,
1835
+ `related_name=${relatedName}`,
1836
+ toField,
1837
+ columnName !== `${attrName}_id` ? `db_column=${toPythonString$1(columnName)}` : null,
1838
+ !relationField.isRequired ? "null=True" : null,
1839
+ ctor === "ForeignKey" ? "db_index=False" : null,
1840
+ ...formatDefaultArgs(model, scalarField, false, names)
1841
+ ].filter((a) => a !== null).join(", ")})`;
1842
+ }
1843
+ function uniqueClassName(preferred, taken) {
1844
+ if (!taken.has(preferred)) return preferred;
1845
+ const suffixed = `${preferred}Through`;
1846
+ if (!taken.has(suffixed)) return suffixed;
1847
+ return Array.from({ length: taken.size + 1 }, (_, i) => `${suffixed}${i + 2}`).find((candidate) => !taken.has(candidate)) ?? suffixed;
1848
+ }
1849
+ function collectManyToManyTables$1(allModels, enums) {
1850
+ const candidates = allModels.flatMap((model) => model.fields.flatMap((field) => {
1851
+ if (field.kind !== "object" || !field.isList) return [];
1852
+ const targetModel = allModels.find((m) => m.name === field.type);
1853
+ if (!targetModel) return [];
1854
+ if (!targetModel.fields.find((f) => f.relationName === field.relationName && f.kind === "object" && !(targetModel.name === model.name && f.name === field.name))?.isList) return [];
1855
+ const [leftName, rightName] = model.name < field.type ? [model.name, field.type] : [field.type, model.name];
1856
+ const relationName = field.relationName ?? `${leftName}To${rightName}`;
1857
+ return [{
1858
+ relationName,
1859
+ tableName: `_${relationName}`,
1860
+ preferredClassName: makePascalCase(relationName),
1861
+ leftModel: leftName,
1862
+ rightModel: rightName
1863
+ }];
1864
+ }));
1865
+ const taken = /* @__PURE__ */ new Set([...allModels.map((m) => makePascalCase(m.name)), ...(enums ?? []).map((e) => makePascalCase(e.name))]);
1866
+ const seen = /* @__PURE__ */ new Set();
1867
+ return candidates.flatMap((candidate) => {
1868
+ if (seen.has(candidate.relationName)) return [];
1869
+ seen.add(candidate.relationName);
1870
+ const className = uniqueClassName(candidate.preferredClassName, taken);
1871
+ taken.add(className);
1872
+ return [{
1873
+ relationName: candidate.relationName,
1874
+ tableName: candidate.tableName,
1875
+ className,
1876
+ leftModel: candidate.leftModel,
1877
+ rightModel: candidate.rightModel
1878
+ }];
1879
+ });
1880
+ }
1881
+ function generateThroughModel(info) {
1882
+ return [
1883
+ `class ${info.className}(models.Model):`,
1884
+ " pk = models.CompositePrimaryKey(\"a_id\", \"b_id\")",
1885
+ ` a = models.ForeignKey("${makePascalCase(info.leftModel)}", on_delete=models.CASCADE, related_name="+", db_column="A", db_index=False)`,
1886
+ ` b = models.ForeignKey("${makePascalCase(info.rightModel)}", on_delete=models.CASCADE, related_name="+", db_column="B", db_index=False)`,
1887
+ "",
1888
+ " class Meta:",
1889
+ ` db_table = ${toPythonString$1(info.tableName)}`,
1890
+ " indexes = [",
1891
+ " models.Index(fields=[\"b\"]),",
1892
+ " ]"
1893
+ ].join("\n");
1894
+ }
1895
+ function generateManyToManyField(model, field, allModels, m2mTables, names) {
1896
+ const backField = findBackRelationField(field, model, allModels);
1897
+ const table = m2mTables.find((t) => t.relationName === field.relationName);
1898
+ if (!table) return null;
1899
+ const attrName = attrNameOf(names, model, field);
1900
+ const relatedName = backField ? toPythonString$1(djangoAttrName(makeSnakeCase(backField.name))) : "\"+\"";
1901
+ const targetClass = makePascalCase(field.type);
1902
+ const args = [
1903
+ `"${targetClass}"`,
1904
+ `through="${table.className}"`,
1905
+ table.leftModel === table.rightModel ? "through_fields=(\"a\", \"b\")" : null,
1906
+ `related_name=${relatedName}`
1907
+ ].filter((a) => a !== null);
1908
+ return ` ${attrName}: ${`"models.ManyToManyField[${targetClass}, ${table.className}]"`} = models.ManyToManyField(${args.join(", ")})`;
1909
+ }
1910
+ function isDeclaringM2MSide(model, field, m2mTables) {
1911
+ const table = m2mTables.find((t) => t.relationName === field.relationName);
1912
+ if (!table) return false;
1913
+ if (table.leftModel !== model.name) return false;
1914
+ if (table.leftModel !== table.rightModel) return true;
1915
+ return model.fields.find((f) => f.kind === "object" && f.relationName === field.relationName)?.name === field.name;
1916
+ }
1917
+ const POSTGRES_INDEX_CLASS = {
1918
+ BTree: "BTreeIndex",
1919
+ Hash: "HashIndex",
1920
+ Gist: "GistIndex",
1921
+ Gin: "GinIndex",
1922
+ SpGist: "SpGistIndex",
1923
+ Brin: "BrinIndex"
1924
+ };
1925
+ function postgresIndexClass(algorithm) {
1926
+ return algorithm === void 0 ? null : POSTGRES_INDEX_CLASS[algorithm] ?? null;
1927
+ }
1928
+ function singleColumnBelongsTo(model) {
1929
+ return model.fields.filter((f) => f.kind === "object" && f.relationFromFields?.length === 1 && f.relationToFields);
1930
+ }
1931
+ function generateMetaLines(model, indexes, names) {
1932
+ const tableName = model.dbName ?? makeSnakeCase(model.name);
1933
+ const fieldRef = (prismaFieldName) => names.attr.get(nameKey(model.name, prismaFieldName)) ?? makeSnakeCase(prismaFieldName);
1934
+ const columnRef = (prismaFieldName) => {
1935
+ const fieldObj = model.fields.find((f) => f.name === prismaFieldName);
1936
+ return fieldObj ? fieldColumnName(fieldObj) : makeSnakeCase(prismaFieldName);
1937
+ };
1938
+ const uniqueIndexes = indexes.filter((idx) => idx.model === model.name && idx.type === "unique" && !idx.isDefinedOnField);
1939
+ const constraints = model.uniqueFields.map((fields) => {
1940
+ return `models.UniqueConstraint(fields=[${fields.map((f) => toPythonString$1(fieldRef(f))).join(", ")}], name=${toPythonString$1(uniqueIndexes.find((idx) => idx.fields.length === fields.length && idx.fields.every((f, i) => f.name === fields[i]))?.dbName ?? `${tableName}_${fields.map((f) => columnRef(f)).join("_")}_key`)})`;
1941
+ });
1942
+ const indexEntries = indexes.filter((idx) => idx.model === model.name && (idx.type === "normal" || idx.type === "fulltext")).map((idx) => {
1943
+ const fieldNames = idx.fields.map((f) => {
1944
+ const ref = fieldRef(f.name);
1945
+ return toPythonString$1(f.sortOrder === "desc" ? `-${ref}` : ref);
1946
+ }).join(", ");
1947
+ const name = idx.dbName !== void 0 && idx.dbName !== null && idx.dbName.length <= 30 && /^[a-zA-Z]/u.test(idx.dbName) ? `, name=${toPythonString$1(idx.dbName)}` : "";
1948
+ const ctor = postgresIndexClass(idx.algorithm);
1949
+ return ctor === null ? `models.Index(fields=[${fieldNames}]${name})` : `${ctor}(fields=[${fieldNames}]${name})`;
1950
+ });
1951
+ return [
1952
+ "",
1953
+ " class Meta:",
1954
+ ` db_table = ${toPythonString$1(tableName)}`,
1955
+ ...constraints.length > 0 ? [
1956
+ " constraints = [",
1957
+ ...constraints.map((c) => ` ${c},`),
1958
+ " ]"
1959
+ ] : [],
1960
+ ...indexEntries.length > 0 ? [
1961
+ " indexes = [",
1962
+ ...indexEntries.map((i) => ` ${i},`),
1963
+ " ]"
1964
+ ] : []
1965
+ ];
1966
+ }
1967
+ function compositePkLine(model, names) {
1968
+ const pkFields = model.primaryKey?.fields ?? [];
1969
+ if (pkFields.length === 0) return null;
1970
+ const belongsTo = singleColumnBelongsTo(model);
1971
+ return ` pk = models.CompositePrimaryKey(${pkFields.map((prismaFieldName) => {
1972
+ const attr = names.attr.get(nameKey(model.name, prismaFieldName)) ?? prismaFieldName;
1973
+ return toPythonString$1(belongsTo.some((f) => f.relationFromFields?.[0] === prismaFieldName) ? `${attr}_id` : attr);
1974
+ }).join(", ")})`;
1975
+ }
1976
+ function findNameConflicts(models, enums) {
1977
+ const byTable = /* @__PURE__ */ new Map();
1978
+ for (const model of models) {
1979
+ const table = model.dbName ?? makeSnakeCase(model.name);
1980
+ byTable.set(table, [...byTable.get(table) ?? [], model.name]);
1981
+ }
1982
+ const tableConflicts = [...byTable].filter(([, owners]) => owners.length > 1).map(([table, owners]) => `models ${owners.join(" and ")} both map to the table "${table}". Add @@map to one of them.`);
1983
+ const columnConflicts = models.flatMap((model) => {
1984
+ const byColumn = /* @__PURE__ */ new Map();
1985
+ for (const field of model.fields) {
1986
+ if (field.kind === "object") continue;
1987
+ const column = fieldColumnName(field);
1988
+ byColumn.set(column, [...byColumn.get(column) ?? [], field.name]);
1989
+ }
1990
+ return [...byColumn].filter(([, owners]) => owners.length > 1).map(([column, owners]) => `fields ${owners.join(" and ")} of model ${model.name} both map to the column "${column}". Add @map to one of them.`);
1991
+ });
1992
+ const byEnumClass = /* @__PURE__ */ new Map();
1993
+ for (const enumDef of enums ?? []) {
1994
+ const className = makePascalCase(enumDef.name);
1995
+ byEnumClass.set(className, [...byEnumClass.get(className) ?? [], enumDef.name]);
1996
+ }
1997
+ const enumConflicts = [...byEnumClass].filter(([, owners]) => owners.length > 1).map(([className, owners]) => `enums ${owners.join(" and ")} both produce the Python class ${className}. Rename one of them.`);
1998
+ return [
1999
+ ...tableConflicts,
2000
+ ...columnConflicts,
2001
+ ...enumConflicts
2002
+ ];
2003
+ }
2004
+ function hasPrimaryKey(model) {
2005
+ return model.fields.some((f) => f.isId) || (model.primaryKey?.fields.length ?? 0) > 0;
2006
+ }
2007
+ function generateModelBody$1(model, allModels, indexes, m2mTables, names) {
2008
+ if (!hasPrimaryKey(model)) return null;
2009
+ const compositePk = compositePkLine(model, names);
2010
+ const belongsTo = singleColumnBelongsTo(model);
2011
+ const fkByScalarName = new Map(belongsTo.map((f) => [f.relationFromFields?.[0], f]));
2012
+ const fieldLines = model.fields.flatMap((field) => {
2013
+ if (field.kind === "object") {
2014
+ if (field.isList && isDeclaringM2MSide(model, field, m2mTables)) {
2015
+ const line = generateManyToManyField(model, field, allModels, m2mTables, names);
2016
+ return line === null ? [] : [line];
2017
+ }
2018
+ return [];
2019
+ }
2020
+ const owner = fkByScalarName.get(field.name);
2021
+ if (owner) return [generateForeignKeyField(model, owner, field, allModels, names)];
2022
+ const isPk = field.isId;
2023
+ return [generateScalarField(model, field, isPk, names)];
2024
+ });
2025
+ return [
2026
+ `class ${makePascalCase(model.name)}(models.Model):`,
2027
+ ...compositePk === null ? [] : [compositePk],
2028
+ ...fieldLines,
2029
+ ...generateMetaLines(model, indexes, names)
2030
+ ].join("\n");
2031
+ }
2032
+ function generateEnumClass(enumDef) {
2033
+ return [`class ${makePascalCase(enumDef.name)}(models.TextChoices):`, ...enumDef.values.map((v) => ` ${enumMemberName(v.name)} = ${toPythonString$1(v.dbName ?? v.name)}`)].join("\n");
2034
+ }
2035
+ function collectGlobalImports$1(models, indexes) {
2036
+ const scalarFields = models.flatMap((m) => m.fields.filter((f) => f.kind !== "object"));
2037
+ const modelNames = new Set(models.map((m) => m.name));
2038
+ const indexClasses = (indexes ?? []).filter((idx) => modelNames.has(idx.model) && (idx.type === "normal" || idx.type === "fulltext")).map((idx) => postgresIndexClass(idx.algorithm)).filter((ctor) => ctor !== null);
2039
+ const needsUuid = scalarFields.some((f) => uuidDefaultVersion$1(f) === 4);
2040
+ const needsUuid6 = scalarFields.some((f) => uuidDefaultVersion$1(f) === 7);
2041
+ const needsUlid = scalarFields.some((f) => isUlidDefault$1(f));
2042
+ const needsArray = scalarFields.some((f) => f.isList);
2043
+ const needsRawSql = scalarFields.some((f) => dbGeneratedExpr(f) !== null);
2044
+ const needsNow = scalarFields.some((f) => isNowDefault(f) && !f.isUpdatedAt);
2045
+ const needsDatetime = scalarFields.some((f) => f.type === "DateTime" && typeof f.default === "string" || f.type === "DateTime" && Array.isArray(f.default) && f.default.some((v) => typeof v === "string"));
2046
+ const needsDecimal = scalarFields.some((f) => f.type === "Decimal" && (typeof f.default === "number" || typeof f.default === "string" || Array.isArray(f.default) && f.default.length > 0));
2047
+ const needsAny = scalarFields.some((f) => {
2048
+ if (f.type !== "Json") return false;
2049
+ if (f.isList) return Array.isArray(f.default) && f.default.length > 0;
2050
+ if (typeof f.default !== "string") return false;
2051
+ const parsed = JSON.parse(f.default);
2052
+ if (typeof parsed !== "object" || parsed === null) return false;
2053
+ return Array.isArray(parsed) ? parsed.length > 0 : Object.keys(parsed).length > 0;
2054
+ });
2055
+ const stdlib = [
2056
+ needsUuid ? "import uuid" : null,
2057
+ needsDatetime ? "from datetime import datetime" : null,
2058
+ needsDecimal ? "from decimal import Decimal" : null,
2059
+ needsAny ? "from typing import Any" : null
2060
+ ].filter((l) => l !== null);
2061
+ const sortedIndexClasses = [...new Set(indexClasses)].toSorted();
2062
+ const thirdParty = [
2063
+ needsUuid6 ? "import uuid6" : null,
2064
+ needsArray ? "from django.contrib.postgres.fields import ArrayField" : null,
2065
+ sortedIndexClasses.length > 0 ? `from django.contrib.postgres.indexes import ${sortedIndexClasses.join(", ")}` : null,
2066
+ "from django.db import models",
2067
+ needsRawSql ? "from django.db.models.expressions import RawSQL" : null,
2068
+ needsNow ? "from django.db.models.functions import Now" : null,
2069
+ needsUlid ? "from ulid import ULID" : null
2070
+ ].filter((l) => l !== null);
2071
+ return stdlib.length > 0 ? [
2072
+ ...stdlib,
2073
+ "",
2074
+ ...thirdParty
2075
+ ] : thirdParty;
2076
+ }
2077
+ //#endregion
2078
+ //#region src/generator/django.ts
2079
+ function djangoCode(models, enums, indexes) {
2080
+ const idx = indexes ?? [];
2081
+ const emitted = models.filter((model) => hasPrimaryKey(model));
2082
+ const m2mTables = collectManyToManyTables$1(emitted, enums);
2083
+ const names = resolveNames(emitted, m2mTables);
2084
+ return `${[
2085
+ collectGlobalImports$1(emitted, idx).join("\n"),
2086
+ ...collectDefaultHelpers(emitted, names, enums),
2087
+ ...(enums ?? []).map((e) => generateEnumClass(e)),
2088
+ ...emitted.map((model) => generateModelBody$1(model, models, idx, m2mTables, names)).filter((body) => body !== null),
2089
+ ...m2mTables.map((t) => generateThroughModel(t))
2090
+ ].join("\n\n\n")}\n`;
2091
+ }
2092
+ //#endregion
2093
+ //#region src/core/django.ts
2094
+ async function django(options) {
2095
+ if (!(options.generator.isCustomOutput && options.generator.output?.value)) return {
2096
+ ok: false,
2097
+ error: "output is required for Hekireki-Django. Please specify output in your generator config."
2098
+ };
2099
+ const output = options.generator.output.value;
2100
+ const outPath = path.extname(output) ? output : path.join(output, "models.py");
2101
+ const enums = options.dmmf.datamodel.enums;
2102
+ const indexes = options.dmmf.datamodel.indexes;
2103
+ const conflicts = findNameConflicts(options.dmmf.datamodel.models, enums);
2104
+ if (conflicts.length > 0) return {
2105
+ ok: false,
2106
+ error: `Hekireki-Django cannot represent this schema:\n${conflicts.map((c) => ` - ${c}`).join("\n")}`
2107
+ };
2108
+ return emitRaw(djangoCode(options.dmmf.datamodel.models, enums, indexes), path.dirname(outPath), outPath);
2109
+ }
2110
+ //#endregion
1414
2111
  //#region src/helper/docs/generator/transform-dmmf.ts
1415
2112
  const legacyName = (mapping, key) => {
1416
2113
  const value = Object.entries(mapping).find(([k]) => k === key)?.[1];
@@ -1974,11 +2671,13 @@ const getFieldDirectives = (field) => {
1974
2671
  const directives = [];
1975
2672
  for (const [k] of filteredEntries) {
1976
2673
  const mappedDirectiveValue = fieldDirectiveMap.get(k);
1977
- if (mappedDirectiveValue) if (k === "hasDefaultValue" && field.default !== void 0) {
1978
- if (typeof field.default === "string" || typeof field.default === "number" || typeof field.default === "boolean") directives.push(`${mappedDirectiveValue}(${field.default})`);
1979
- else if (Array.isArray(field.default)) directives.push(`${mappedDirectiveValue}([${field.default.toString()}])`);
1980
- else if (isFieldDefault$1(field.default)) directives.push(`${mappedDirectiveValue}(${field.default.name}(${field.default.args.join(",")}))`);
1981
- } else directives.push(mappedDirectiveValue);
2674
+ if (mappedDirectiveValue) {
2675
+ if (k === "hasDefaultValue" && field.default !== void 0) {
2676
+ if (typeof field.default === "string" || typeof field.default === "number" || typeof field.default === "boolean") directives.push(`${mappedDirectiveValue}(${field.default})`);
2677
+ else if (Array.isArray(field.default)) directives.push(`${mappedDirectiveValue}([${field.default.toString()}])`);
2678
+ else if (isFieldDefault$1(field.default)) directives.push(`${mappedDirectiveValue}(${field.default.name}(${field.default.args.join(",")}))`);
2679
+ } else directives.push(mappedDirectiveValue);
2680
+ }
1982
2681
  }
1983
2682
  return directives;
1984
2683
  };
@@ -2355,7 +3054,8 @@ const generateHTML = async (data) => {
2355
3054
  types: createTypes(data)
2356
3055
  })]
2357
3056
  }) });
2358
- return `<!DOCTYPE html>${await resolveCallback(await Promise.resolve(element).then((node) => node.toString()), HtmlEscapedCallbackPhase.Stringify, false, {})}`;
3057
+ const rendered = await Promise.resolve(element).then((node) => node.toString());
3058
+ return `<!DOCTYPE html>${await resolveCallback(rendered, HtmlEscapedCallbackPhase.Stringify, false, {})}`;
2359
3059
  };
2360
3060
  //#endregion
2361
3061
  //#region src/generator/docs.ts
@@ -5794,6 +6494,10 @@ const GENERATORS = {
5794
6494
  prettyName: "Hekireki-DBML",
5795
6495
  handler: dbml
5796
6496
  },
6497
+ django: {
6498
+ prettyName: "Hekireki-Django",
6499
+ handler: django
6500
+ },
5797
6501
  docs: {
5798
6502
  prettyName: "Hekireki-Docs",
5799
6503
  handler: docs
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "hekireki",
3
- "version": "0.10.1",
3
+ "version": "0.10.2",
4
4
  "description": "Generate validation schemas, ORM models, and ER diagrams from Prisma schemas.",
5
5
  "keywords": [
6
6
  "activerecord",
@@ -8,6 +8,7 @@
8
8
  "arktype",
9
9
  "atlas",
10
10
  "dbml",
11
+ "django",
11
12
  "docs",
12
13
  "documentation",
13
14
  "ecto",
@@ -47,6 +48,7 @@
47
48
  "hekireki-arktype": "dist/bin/arktype.js",
48
49
  "hekireki-atlas": "dist/bin/atlas.js",
49
50
  "hekireki-dbml": "dist/bin/dbml.js",
51
+ "hekireki-django": "dist/bin/django.js",
50
52
  "hekireki-docs": "dist/bin/docs.js",
51
53
  "hekireki-drizzle": "dist/bin/drizzle.js",
52
54
  "hekireki-ecto": "dist/bin/ecto.js",