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 +58 -0
- package/dist/bin/activerecord.js +1 -1
- package/dist/bin/ajv.js +1 -1
- package/dist/bin/arktype.js +1 -1
- package/dist/bin/atlas.js +1 -1
- package/dist/bin/dbml.js +1 -1
- package/dist/bin/django.d.ts +1 -0
- package/dist/bin/django.js +6 -0
- package/dist/bin/docs.js +1 -1
- package/dist/bin/drizzle.js +1 -1
- package/dist/bin/ecto.js +1 -1
- package/dist/bin/effect.js +1 -1
- package/dist/bin/eloquent.js +1 -1
- package/dist/bin/gorm.js +1 -1
- package/dist/bin/kysely.js +1 -1
- package/dist/bin/mermaid-er.js +1 -1
- package/dist/bin/pydantic.js +1 -1
- package/dist/bin/sea-orm.js +1 -1
- package/dist/bin/sqlalchemy.js +1 -1
- package/dist/bin/typebox.js +1 -1
- package/dist/bin/valibot.js +1 -1
- package/dist/bin/zod.js +1 -1
- package/dist/{bin-CR9GrJIk.js โ bin-9aHkP_Bs.js} +716 -12
- package/package.json +3 -1
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"
|
package/dist/bin/activerecord.js
CHANGED
package/dist/bin/ajv.js
CHANGED
package/dist/bin/arktype.js
CHANGED
package/dist/bin/atlas.js
CHANGED
package/dist/bin/dbml.js
CHANGED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {}
|
package/dist/bin/docs.js
CHANGED
package/dist/bin/drizzle.js
CHANGED
package/dist/bin/ecto.js
CHANGED
package/dist/bin/effect.js
CHANGED
package/dist/bin/eloquent.js
CHANGED
package/dist/bin/gorm.js
CHANGED
package/dist/bin/kysely.js
CHANGED
package/dist/bin/mermaid-er.js
CHANGED
package/dist/bin/pydantic.js
CHANGED
package/dist/bin/sea-orm.js
CHANGED
package/dist/bin/sqlalchemy.js
CHANGED
package/dist/bin/typebox.js
CHANGED
package/dist/bin/valibot.js
CHANGED
package/dist/bin/zod.js
CHANGED
|
@@ -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$
|
|
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$
|
|
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$
|
|
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$
|
|
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$
|
|
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
|
-
|
|
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)
|
|
1978
|
-
if (
|
|
1979
|
-
|
|
1980
|
-
|
|
1981
|
-
|
|
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
|
-
|
|
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.
|
|
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",
|