@prisma-next/target-postgres 0.10.0 → 0.11.0

package/dist/control.mjs

@@ -1,11 +1,11 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-zrZzWmJF.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DLA2xV6B.mjs";
 import { t as parsePostgresDefault } from "./default-normalizer-DHCsbfjc.mjs";
 import { t as normalizeSchemaNativeType } from "./native-type-normalizer-DMikJJ1V.mjs";
 import { r as readExistingEnumValues } from "./enum-planning-Bqp96iIw.mjs";
-import { o as renderDefaultLiteral } from "./planner-ddl-builders-DINYrbJ3.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-C8yhbXOq.mjs";
+import { o as renderDefaultLiteral } from "./planner-ddl-builders-DYMuN0w1.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-DZG1dsSW.mjs";
 import { a as ensureMarkerTableStatement, i as ensureLedgerTableStatement, n as buildLedgerInsertStatement, o as ensurePrismaContractSchemaStatement, r as buildMergeMarkerStatements } from "./statement-builders-vImtdfmM.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-CcZO9ukP.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-CrET5Ov0.mjs";
 import { contractToSchemaIR, extractCodecControlHooks, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";

package/dist/descriptor-meta-DLA2xV6B.mjs

@@ -0,0 +1,126 @@
+import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
+import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
+import { PostgresEnumTypeSchema } from "@prisma-next/sql-contract/validators";
+//#region src/core/authoring.ts
+const postgresAuthoringTypes = {};
+/**
+* Entity type contributions surface as top-level helpers on the
+* composed-helpers shape (e.g. `helpers.enum({...})`), flattened
+* alongside the built-in `model` / `rel` helpers. Pack contributions
+* still ship via the contribution data structure
+* `authoring.entityTypes.<name>`; the composed-helpers template
+* performs the rename in the type system.
+*
+* `enum` is the first real consumer of the entities-namespace mechanism:
+* the factory constructs a `PostgresEnumType` IR-class instance from
+* the user-supplied input. Both authoring runtimes (TS DSL and PSL)
+* dispatch through this single contribution — PSL `enum Status { … }`
+* declarations are lowered by the interpreter into a factory call
+* with the parsed name + value list; TS DSL `helpers.enum({...})`
+* resolves through the same path. Removing this contribution makes
+* both surfaces fail with a "no entity helper named `enum`" type
+* error at the contract-definition site.
+*/
+/**
+* The factory constructs a `PostgresEnumType` instance natively — the
+* `SqlStorage.types` slot accepts polymorphic IR (the framework
+* `StorageType` alphabet), so no cast is needed at the contribution
+* surface. The declared return type is the structural
+* `PostgresEnumStorageEntry` so the inferred contract type stays
+* portable (it names a type exported from
+* `@prisma-next/sql-contract/types`, a public surface every consumer
+* already imports). Sharpening the inferred contract type to surface
+* enum-specific narrowing through `EntityHelperFunction` is a
+* separable refinement and lives outside this PR.
+*/
+const postgresAuthoringEntityTypes = { enum: {
+	kind: "entity",
+	discriminator: "postgres-enum",
+	validatorSchema: PostgresEnumTypeSchema,
+	output: { factory: (input) => new PostgresEnumType(input) }
+} };
+const postgresTargetDescriptorMeta = {
+	kind: "target",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {},
+	authoring: {
+		type: postgresAuthoringTypes,
+		field: {
+			text: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/text@1",
+					nativeType: "text"
+				}
+			},
+			int: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/int4@1",
+					nativeType: "int4"
+				}
+			},
+			bigint: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/int8@1",
+					nativeType: "int8"
+				}
+			},
+			float: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/float8@1",
+					nativeType: "float8"
+				}
+			},
+			decimal: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/numeric@1",
+					nativeType: "numeric"
+				}
+			},
+			boolean: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/bool@1",
+					nativeType: "bool"
+				}
+			},
+			json: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/jsonb@1",
+					nativeType: "jsonb"
+				}
+			},
+			bytes: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/bytea@1",
+					nativeType: "bytea"
+				}
+			},
+			dateTime: {
+				kind: "fieldPreset",
+				output: {
+					codecId: "pg/timestamptz@1",
+					nativeType: "timestamptz"
+				}
+			},
+			temporal: temporalAuthoringPresets({
+				codecId: "pg/timestamptz@1",
+				nativeType: "timestamptz"
+			})
+		},
+		entityTypes: postgresAuthoringEntityTypes
+	}
+};
+//#endregion
+export { postgresAuthoringEntityTypes as n, postgresTargetDescriptorMeta as t };
+
+//# sourceMappingURL=descriptor-meta-DLA2xV6B.mjs.map

package/dist/descriptor-meta-DLA2xV6B.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-DLA2xV6B.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\nimport type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';\nimport { PostgresEnumTypeSchema } from '@prisma-next/sql-contract/validators';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\n\nexport const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;\n\n/**\n * Entity type contributions surface as top-level helpers on the\n * composed-helpers shape (e.g. `helpers.enum({...})`), flattened\n * alongside the built-in `model` / `rel` helpers. Pack contributions\n * still ship via the contribution data structure\n * `authoring.entityTypes.<name>`; the composed-helpers template\n * performs the rename in the type system.\n *\n * `enum` is the first real consumer of the entities-namespace mechanism:\n * the factory constructs a `PostgresEnumType` IR-class instance from\n * the user-supplied input. Both authoring runtimes (TS DSL and PSL)\n * dispatch through this single contribution — PSL `enum Status { … }`\n * declarations are lowered by the interpreter into a factory call\n * with the parsed name + value list; TS DSL `helpers.enum({...})`\n * resolves through the same path. Removing this contribution makes\n * both surfaces fail with a \"no entity helper named `enum`\" type\n * error at the contract-definition site.\n */\n/**\n * The factory constructs a `PostgresEnumType` instance natively — the\n * `SqlStorage.types` slot accepts polymorphic IR (the framework\n * `StorageType` alphabet), so no cast is needed at the contribution\n * surface. The declared return type is the structural\n * `PostgresEnumStorageEntry` so the inferred contract type stays\n * portable (it names a type exported from\n * `@prisma-next/sql-contract/types`, a public surface every consumer\n * already imports). Sharpening the inferred contract type to surface\n * enum-specific narrowing through `EntityHelperFunction` is a\n * separable refinement and lives outside this PR.\n */\nexport const postgresAuthoringEntityTypes = {\n  enum: {\n    kind: 'entity',\n    discriminator: 'postgres-enum',\n    validatorSchema: PostgresEnumTypeSchema,\n    output: {\n      factory: (input: PostgresEnumTypeInput): PostgresEnumStorageEntry =>\n        new PostgresEnumType(input),\n    },\n  },\n} as const satisfies AuthoringEntityTypeNamespace;\n\n/**\n * Field presets contributed by the Postgres target pack.\n *\n * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter\n * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field\n * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar\n * surface (e.g. `Int`) lowers to byte-identical contracts.\n */\nexport const postgresAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/text@1',\n      nativeType: 'text',\n    },\n  },\n  int: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int4@1',\n      nativeType: 'int4',\n    },\n  },\n  bigint: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int8@1',\n      nativeType: 'int8',\n    },\n  },\n  float: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/float8@1',\n      nativeType: 'float8',\n    },\n  },\n  decimal: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/numeric@1',\n      nativeType: 'numeric',\n    },\n  },\n  boolean: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bool@1',\n      nativeType: 'bool',\n    },\n  },\n  json: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/jsonb@1',\n      nativeType: 'jsonb',\n    },\n  },\n  bytes: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bytea@1',\n      nativeType: 'bytea',\n    },\n  },\n  dateTime: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n    },\n  },\n  temporal: temporalAuthoringPresets({\n    codecId: 'pg/timestamptz@1',\n    nativeType: 'timestamptz',\n  }),\n} as const satisfies AuthoringFieldNamespace;\n","import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringTypes,\n} from './authoring';\n\nconst postgresTargetDescriptorMetaBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";;;;AAUA,MAAa,yBAAyB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCxC,MAAa,+BAA+B,EAC1C,MAAM;CACJ,MAAM;CACN,eAAe;CACf,iBAAiB;CACjB,QAAQ,EACN,UAAU,UACR,IAAI,iBAAiB,MAAM,EAC9B;CACF,EACF;AC/BD,MAAa,+BAET;CAfF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CAChB,WAAW;EACT,MAAM;EACN,OAAO;GD+CT,MAAM;IACJ,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,KAAK;IACH,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,QAAQ;IACN,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,OAAO;IACL,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,SAAS;IACP,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,SAAS;IACP,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,MAAM;IACJ,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,OAAO;IACL,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,UAAU;IACR,MAAM;IACN,QAAQ;KACN,SAAS;KACT,YAAY;KACb;IACF;GACD,UAAU,yBAAyB;IACjC,SAAS;IACT,YAAY;IACb,CAAC;GCjHO;EACP,aAAa;EACd;CAKC"}

package/dist/{issue-planner-qalHRCI2.mjs → issue-planner-OthDciOe.mjs}

@@ -1,10 +1,10 @@
 import { t as PostgresEnumType } from "./postgres-enum-type-DS-KLVRH.mjs";
 import { r as readExistingEnumValues, t as determineEnumDiff } from "./enum-planning-Bqp96iIw.mjs";
 import { i as quoteIdentifier } from "./sql-utils-BewXAnsG.mjs";
-import { r as isPostgresSchema } from "./postgres-schema-BosNxhWq.mjs";
-import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-BM4sD6Xc.mjs";
-import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-Zsrdty3k.mjs";
-import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-DINYrbJ3.mjs";
+import { r as isPostgresSchema } from "./postgres-schema-CK82EuWq.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-K-mTBJDi.mjs";
+import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-Bgb_ghPb.mjs";
+import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-DYMuN0w1.mjs";
 import { n as resolveIdentityValue } from "./planner-identity-values-ojX-6cPV.mjs";
 import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-BGyukuzG.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -976,4 +976,4 @@ function planIssues(options) {
 //#endregion
 export { postgresPlannerStrategies as n, planIssues as t };
 
-//# sourceMappingURL=issue-planner-qalHRCI2.mjs.map
+//# sourceMappingURL=issue-planner-OthDciOe.mjs.map