@prisma-next/target-postgres 0.5.0-dev.7 → 0.5.0-dev.70

package/dist/codecs-D-F2KJqt.d.mts

@@ -1,299 +0,0 @@
-import * as _prisma_next_sql_relational_core_ast0 from "@prisma-next/sql-relational-core/ast";
-import { Codec } from "@prisma-next/sql-relational-core/ast";
-import { JsonValue } from "@prisma-next/contract/types";
-
-//#region src/core/codecs.d.ts
-
-declare const codecs: _prisma_next_sql_relational_core_ast0.CodecDefBuilder<{
-  char: Codec<"sql/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  varchar: Codec<"sql/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  int: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  float: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  "sql-text": Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  "sql-timestamp": Codec<"sql/timestamp@1", readonly ["equality", "order"], string, string, {
-    precision?: number;
-  }, unknown>;
-  text: Codec<"pg/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  character: Codec<"pg/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  "character varying": Codec<"pg/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-  integer: Codec<"pg/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  "double precision": Codec<"pg/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  int4: Codec<"pg/int4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  int2: Codec<"pg/int2@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  int8: Codec<"pg/int8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  float4: Codec<"pg/float4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  float8: Codec<"pg/float8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-  numeric: Codec<"pg/numeric@1", readonly ["equality", "order", "numeric"], string, string, Record<string, unknown>, unknown>;
-  timestamp: Codec<"pg/timestamp@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
-  timestamptz: Codec<"pg/timestamptz@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
-  time: Codec<"pg/time@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-  timetz: Codec<"pg/timetz@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-  bool: Codec<"pg/bool@1", readonly ["equality", "boolean"], boolean, boolean, Record<string, unknown>, unknown>;
-  bit: Codec<"pg/bit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-  "bit varying": Codec<"pg/varbit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-  interval: Codec<"pg/interval@1", readonly ["equality", "order"], string | Record<string, unknown>, string, Record<string, unknown>, unknown>;
-  enum: Codec<"pg/enum@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-  json: Codec<"pg/json@1", readonly [], string, JsonValue, Record<string, unknown>, unknown>;
-} & Record<"jsonb", Codec<"pg/jsonb@1", readonly ["equality"], string, JsonValue, Record<string, unknown>, unknown>>>;
-declare const codecDefinitions: {
-  readonly char: {
-    readonly typeId: "sql/char@1";
-    readonly scalar: "char";
-    readonly codec: Codec<"sql/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly varchar: {
-    readonly typeId: "sql/varchar@1";
-    readonly scalar: "varchar";
-    readonly codec: Codec<"sql/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly int: {
-    readonly typeId: "sql/int@1";
-    readonly scalar: "int";
-    readonly codec: Codec<"sql/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly float: {
-    readonly typeId: "sql/float@1";
-    readonly scalar: "float";
-    readonly codec: Codec<"sql/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly "sql-text": {
-    readonly typeId: "sql/text@1";
-    readonly scalar: "sql-text";
-    readonly codec: Codec<"sql/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly "sql-timestamp": {
-    readonly typeId: "sql/timestamp@1";
-    readonly scalar: "sql-timestamp";
-    readonly codec: Codec<"sql/timestamp@1", readonly ["equality", "order"], string, string, {
-      precision?: number;
-    }, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly text: {
-    readonly typeId: "pg/text@1";
-    readonly scalar: "text";
-    readonly codec: Codec<"pg/text@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly character: {
-    readonly typeId: "pg/char@1";
-    readonly scalar: "character";
-    readonly codec: Codec<"pg/char@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly "character varying": {
-    readonly typeId: "pg/varchar@1";
-    readonly scalar: "character varying";
-    readonly codec: Codec<"pg/varchar@1", readonly ["equality", "order", "textual"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly integer: {
-    readonly typeId: "pg/int@1";
-    readonly scalar: "integer";
-    readonly codec: Codec<"pg/int@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly "double precision": {
-    readonly typeId: "pg/float@1";
-    readonly scalar: "double precision";
-    readonly codec: Codec<"pg/float@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly int4: {
-    readonly typeId: "pg/int4@1";
-    readonly scalar: "int4";
-    readonly codec: Codec<"pg/int4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly int2: {
-    readonly typeId: "pg/int2@1";
-    readonly scalar: "int2";
-    readonly codec: Codec<"pg/int2@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly int8: {
-    readonly typeId: "pg/int8@1";
-    readonly scalar: "int8";
-    readonly codec: Codec<"pg/int8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly float4: {
-    readonly typeId: "pg/float4@1";
-    readonly scalar: "float4";
-    readonly codec: Codec<"pg/float4@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly float8: {
-    readonly typeId: "pg/float8@1";
-    readonly scalar: "float8";
-    readonly codec: Codec<"pg/float8@1", readonly ["equality", "order", "numeric"], number, number, Record<string, unknown>, unknown>;
-    readonly input: number;
-    readonly output: number;
-    readonly jsType: number;
-  };
-  readonly numeric: {
-    readonly typeId: "pg/numeric@1";
-    readonly scalar: "numeric";
-    readonly codec: Codec<"pg/numeric@1", readonly ["equality", "order", "numeric"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly timestamp: {
-    readonly typeId: "pg/timestamp@1";
-    readonly scalar: "timestamp";
-    readonly codec: Codec<"pg/timestamp@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
-    readonly input: string | Date;
-    readonly output: string | Date;
-    readonly jsType: string | Date;
-  };
-  readonly timestamptz: {
-    readonly typeId: "pg/timestamptz@1";
-    readonly scalar: "timestamptz";
-    readonly codec: Codec<"pg/timestamptz@1", readonly ["equality", "order"], string | Date, string | Date, Record<string, unknown>, unknown>;
-    readonly input: string | Date;
-    readonly output: string | Date;
-    readonly jsType: string | Date;
-  };
-  readonly time: {
-    readonly typeId: "pg/time@1";
-    readonly scalar: "time";
-    readonly codec: Codec<"pg/time@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly timetz: {
-    readonly typeId: "pg/timetz@1";
-    readonly scalar: "timetz";
-    readonly codec: Codec<"pg/timetz@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly bool: {
-    readonly typeId: "pg/bool@1";
-    readonly scalar: "bool";
-    readonly codec: Codec<"pg/bool@1", readonly ["equality", "boolean"], boolean, boolean, Record<string, unknown>, unknown>;
-    readonly input: boolean;
-    readonly output: boolean;
-    readonly jsType: boolean;
-  };
-  readonly bit: {
-    readonly typeId: "pg/bit@1";
-    readonly scalar: "bit";
-    readonly codec: Codec<"pg/bit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly "bit varying": {
-    readonly typeId: "pg/varbit@1";
-    readonly scalar: "bit varying";
-    readonly codec: Codec<"pg/varbit@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly interval: {
-    readonly typeId: "pg/interval@1";
-    readonly scalar: "interval";
-    readonly codec: Codec<"pg/interval@1", readonly ["equality", "order"], string | Record<string, unknown>, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly enum: {
-    readonly typeId: "pg/enum@1";
-    readonly scalar: "enum";
-    readonly codec: Codec<"pg/enum@1", readonly ["equality", "order"], string, string, Record<string, unknown>, unknown>;
-    readonly input: string;
-    readonly output: string;
-    readonly jsType: string;
-  };
-  readonly json: {
-    readonly typeId: "pg/json@1";
-    readonly scalar: "json";
-    readonly codec: Codec<"pg/json@1", readonly [], string, JsonValue, Record<string, unknown>, unknown>;
-    readonly input: JsonValue;
-    readonly output: JsonValue;
-    readonly jsType: JsonValue;
-  };
-  readonly jsonb: {
-    readonly typeId: "pg/jsonb@1";
-    readonly scalar: "jsonb";
-    readonly codec: Codec<"pg/jsonb@1", readonly ["equality"], string, JsonValue, Record<string, unknown>, unknown>;
-    readonly input: JsonValue;
-    readonly output: JsonValue;
-    readonly jsType: JsonValue;
-  };
-};
-declare const dataTypes: {
-  readonly char: "sql/char@1";
-  readonly varchar: "sql/varchar@1";
-  readonly int: "sql/int@1";
-  readonly float: "sql/float@1";
-  readonly "sql-text": "sql/text@1";
-  readonly "sql-timestamp": "sql/timestamp@1";
-  readonly text: "pg/text@1";
-  readonly character: "pg/char@1";
-  readonly "character varying": "pg/varchar@1";
-  readonly integer: "pg/int@1";
-  readonly "double precision": "pg/float@1";
-  readonly int4: "pg/int4@1";
-  readonly int2: "pg/int2@1";
-  readonly int8: "pg/int8@1";
-  readonly float4: "pg/float4@1";
-  readonly float8: "pg/float8@1";
-  readonly numeric: "pg/numeric@1";
-  readonly timestamp: "pg/timestamp@1";
-  readonly timestamptz: "pg/timestamptz@1";
-  readonly time: "pg/time@1";
-  readonly timetz: "pg/timetz@1";
-  readonly bool: "pg/bool@1";
-  readonly bit: "pg/bit@1";
-  readonly "bit varying": "pg/varbit@1";
-  readonly interval: "pg/interval@1";
-  readonly enum: "pg/enum@1";
-  readonly json: "pg/json@1";
-  readonly jsonb: "pg/jsonb@1";
-};
-type CodecTypes = typeof codecs.CodecTypes;
-//#endregion
-export { codecDefinitions as n, dataTypes as r, CodecTypes as t };
-//# sourceMappingURL=codecs-D-F2KJqt.d.mts.map

package/dist/codecs-D-F2KJqt.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codecs-D-F2KJqt.d.mts","names":[],"sources":["../src/core/codecs.ts"],"sourcesContent":[],"mappings":";;;;;;cAkmBM,8CAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BC;;;;;;;;;;;;;;;;;;;;;;;;;EA/BD,SAAA,KAAA,EAAA;IA+BC,SAAA,MAA0C,EAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAC1C,SAA4B,KAAA,OAAA,CAAA,WAAA,EAAA,SAAA,CAAA,UAAA,EAAA,OAAA,EAAA,SAAA,CAAA,EAAA,MAAA,EAAA,MAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA;IAE7B,SAAU,KAAA,EAAA,MAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAFnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAED,UAAA,UAAoB,MAAA,CAAO"}

package/dist/data-transform-CxFRBIUp.d.mts

@@ -1,32 +0,0 @@
-import { Contract } from "@prisma-next/contract/types";
-import { SqlStorage } from "@prisma-next/sql-contract/types";
-import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
-import { DataTransformOperation } from "@prisma-next/framework-components/control";
-import { SqlQueryPlan } from "@prisma-next/sql-relational-core/plan";
-
-//#region src/core/migrations/operations/data-transform.d.ts
-
-interface Buildable<R = unknown> {
-  build(): SqlQueryPlan<R>;
-}
-/**
- * A single-closure producer of a SQL query plan. Shared between
- * `check` and each `run` entry.
- */
-type DataTransformClosure = () => SqlQueryPlan | Buildable;
-interface DataTransformOptions {
-  /** Optional pre-flight query. `undefined` means "no check". */
-  readonly check?: DataTransformClosure;
-  /** One or more mutation queries to execute. */
-  readonly run: DataTransformClosure | readonly DataTransformClosure[];
-}
-/**
- * Concrete Postgres flavor of `DataTransformOperation`, re-exported so the
- * `PostgresMigration.dataTransform` instance method can name it without
- * leaking the framework-components symbol into call sites.
- */
-type PostgresDataTransformOperation = DataTransformOperation;
-declare function dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions, adapter: SqlControlAdapter<'postgres'>): DataTransformOperation;
-//#endregion
-export { dataTransform as i, DataTransformOptions as n, PostgresDataTransformOperation as r, DataTransformClosure as t };
-//# sourceMappingURL=data-transform-CxFRBIUp.d.mts.map

package/dist/data-transform-CxFRBIUp.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-transform-CxFRBIUp.d.mts","names":[],"sources":["../src/core/migrations/operations/data-transform.ts"],"sourcesContent":[],"mappings":";;;;;;;;UAwCU;WACC,aAAa;;;;;;KAOZ,oBAAA,SAA6B,eAAe;UAEvC,oBAAA;;mBAEE;;gBAEH,gCAAgC;;;;;;;KAQpC,8BAAA,GAAiC;iBAE7B,gCAAgC,SAAS,uBAC7C,kCAED,+BACA,gCACR"}

package/dist/data-transform-VfEGzXWt.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-transform-VfEGzXWt.mjs","names":["runClosures: readonly DataTransformClosure[]"],"sources":["../src/core/migrations/operations/data-transform.ts"],"sourcesContent":["/**\n * User-facing `dataTransform` factory for the Postgres migration authoring\n * surface. Invoked directly inside a `migration.ts` file via the\n * `PostgresMigration` instance method (`this.dataTransform(...)`), which\n * supplies the control adapter from the migration's injected stack:\n *\n * ```ts\n * import endContract from './end-contract.json' with { type: 'json' };\n *\n * class M extends Migration {\n *   override get operations() {\n *     return [\n *       this.dataTransform(endContract, 'backfill emails', {\n *         check: () => db.users.count().where(({ email }) => email.isNull()),\n *         run:   () => db.users.update({ email: '' }).where(({ email }) => email.isNull()),\n *       }),\n *     ];\n *   }\n * }\n * ```\n *\n * The factory accepts lazy closures (`() => SqlQueryPlan | Buildable`),\n * invokes each one, asserts that its `meta.storageHash` matches the\n * `contract` it was handed (→ `PN-MIG-2005` on mismatch), and lowers the\n * plan via the supplied control adapter to a serialized `{sql, params}`\n * payload for `ops.json`. The free factory remains usable standalone\n * (tests, ad-hoc tooling, non-class contexts) by passing the adapter\n * explicitly as the fourth argument.\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport { errorDataTransformContractMismatch } from '@prisma-next/errors/migration';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport type {\n  DataTransformOperation,\n  SerializedQueryPlan,\n} from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\n\ninterface Buildable<R = unknown> {\n  build(): SqlQueryPlan<R>;\n}\n\n/**\n * A single-closure producer of a SQL query plan. Shared between\n * `check` and each `run` entry.\n */\nexport type DataTransformClosure = () => SqlQueryPlan | Buildable;\n\nexport interface DataTransformOptions {\n  /** Optional pre-flight query. `undefined` means \"no check\". */\n  readonly check?: DataTransformClosure;\n  /** One or more mutation queries to execute. */\n  readonly run: DataTransformClosure | readonly DataTransformClosure[];\n}\n\n/**\n * Concrete Postgres flavor of `DataTransformOperation`, re-exported so the\n * `PostgresMigration.dataTransform` instance method can name it without\n * leaking the framework-components symbol into call sites.\n */\nexport type PostgresDataTransformOperation = DataTransformOperation;\n\nexport function dataTransform<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  name: string,\n  options: DataTransformOptions,\n  adapter: SqlControlAdapter<'postgres'>,\n): DataTransformOperation {\n  const runClosures: readonly DataTransformClosure[] = Array.isArray(options.run)\n    ? options.run\n    : [options.run as DataTransformClosure];\n  return {\n    id: `data_migration.${name}`,\n    label: `Data transform: ${name}`,\n    operationClass: 'data',\n    name,\n    source: 'migration.ts',\n    check: options.check ? invokeAndLower(options.check, contract, adapter, name) : null,\n    run: runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name)),\n  };\n}\n\nfunction invokeAndLower(\n  closure: DataTransformClosure,\n  contract: Contract<SqlStorage>,\n  adapter: SqlControlAdapter<'postgres'>,\n  name: string,\n): SerializedQueryPlan {\n  const result = closure();\n  const plan = isBuildable(result) ? result.build() : result;\n  assertContractMatches(plan, contract, name);\n  const lowered = adapter.lower(plan.ast, { contract });\n  return { sql: lowered.sql, params: lowered.params };\n}\n\nfunction isBuildable(value: unknown): value is Buildable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'build' in value &&\n    typeof (value as { build: unknown }).build === 'function'\n  );\n}\n\nfunction assertContractMatches(\n  plan: SqlQueryPlan,\n  contract: Contract<SqlStorage>,\n  name: string,\n): void {\n  if (plan.meta.storageHash !== contract.storage.storageHash) {\n    throw errorDataTransformContractMismatch({\n      dataTransformName: name,\n      expected: contract.storage.storageHash,\n      actual: plan.meta.storageHash,\n    });\n  }\n}\n"],"mappings":";;;AAgEA,SAAgB,cACd,UACA,MACA,SACA,SACwB;CACxB,MAAMA,cAA+C,MAAM,QAAQ,QAAQ,IAAI,GAC3E,QAAQ,MACR,CAAC,QAAQ,IAA4B;AACzC,QAAO;EACL,IAAI,kBAAkB;EACtB,OAAO,mBAAmB;EAC1B,gBAAgB;EAChB;EACA,QAAQ;EACR,OAAO,QAAQ,QAAQ,eAAe,QAAQ,OAAO,UAAU,SAAS,KAAK,GAAG;EAChF,KAAK,YAAY,KAAK,YAAY,eAAe,SAAS,UAAU,SAAS,KAAK,CAAC;EACpF;;AAGH,SAAS,eACP,SACA,UACA,SACA,MACqB;CACrB,MAAM,SAAS,SAAS;CACxB,MAAM,OAAO,YAAY,OAAO,GAAG,OAAO,OAAO,GAAG;AACpD,uBAAsB,MAAM,UAAU,KAAK;CAC3C,MAAM,UAAU,QAAQ,MAAM,KAAK,KAAK,EAAE,UAAU,CAAC;AACrD,QAAO;EAAE,KAAK,QAAQ;EAAK,QAAQ,QAAQ;EAAQ;;AAGrD,SAAS,YAAY,OAAoC;AACvD,QACE,OAAO,UAAU,YACjB,UAAU,QACV,WAAW,SACX,OAAQ,MAA6B,UAAU;;AAInD,SAAS,sBACP,MACA,UACA,MACM;AACN,KAAI,KAAK,KAAK,gBAAgB,SAAS,QAAQ,YAC7C,OAAM,mCAAmC;EACvC,mBAAmB;EACnB,UAAU,SAAS,QAAQ;EAC3B,QAAQ,KAAK,KAAK;EACnB,CAAC"}

package/dist/descriptor-meta-BVoVtyp-.mjs

@@ -1,120 +0,0 @@
-//#region src/core/authoring.ts
-const postgresAuthoringTypes = { enum: {
-	kind: "typeConstructor",
-	args: [{ kind: "string" }, { kind: "stringArray" }],
-	output: {
-		codecId: "pg/enum@1",
-		nativeType: {
-			kind: "arg",
-			index: 0
-		},
-		typeParams: { values: {
-			kind: "arg",
-			index: 1
-		} }
-	}
-} };
-/**
-* Field presets contributed by the Postgres target pack.
-*
-* These mirror the PSL scalar-to-codec mapping used by the Postgres adapter
-* (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
-* via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
-* surface (e.g. `Int`) lowers to byte-identical contracts.
-*/
-const postgresAuthoringFieldPresets = {
-	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"
-		}
-	},
-	createdAt: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/timestamptz@1",
-			nativeType: "timestamptz",
-			default: {
-				kind: "function",
-				expression: "now()"
-			}
-		}
-	}
-};
-
-//#endregion
-//#region src/core/descriptor-meta.ts
-const postgresTargetDescriptorMetaBase = {
-	kind: "target",
-	familyId: "sql",
-	targetId: "postgres",
-	id: "postgres",
-	version: "0.0.1",
-	capabilities: {},
-	authoring: {
-		type: postgresAuthoringTypes,
-		field: postgresAuthoringFieldPresets
-	}
-};
-const postgresTargetDescriptorMeta = postgresTargetDescriptorMetaBase;
-
-//#endregion
-export { postgresTargetDescriptorMeta as t };
-//# sourceMappingURL=descriptor-meta-BVoVtyp-.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-BVoVtyp-.mjs","names":["postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n}"],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import type {\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\n\nexport const postgresAuthoringTypes = {\n  enum: {\n    kind: 'typeConstructor',\n    args: [{ kind: 'string' }, { kind: 'stringArray' }],\n    output: {\n      codecId: 'pg/enum@1',\n      nativeType: { kind: 'arg', index: 0 },\n      typeParams: {\n        values: { kind: 'arg', index: 1 },\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\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  createdAt: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n      default: {\n        kind: 'function',\n        expression: 'now()',\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n","import { postgresAuthoringFieldPresets, postgresAuthoringTypes } from './authoring';\nimport type { CodecTypes } from './codecs';\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  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";AAKA,MAAa,yBAAyB,EACpC,MAAM;CACJ,MAAM;CACN,MAAM,CAAC,EAAE,MAAM,UAAU,EAAE,EAAE,MAAM,eAAe,CAAC;CACnD,QAAQ;EACN,SAAS;EACT,YAAY;GAAE,MAAM;GAAO,OAAO;GAAG;EACrC,YAAY,EACV,QAAQ;GAAE,MAAM;GAAO,OAAO;GAAG,EAClC;EACF;CACF,EACF;;;;;;;;;AAUD,MAAa,gCAAgC;CAC3C,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,KAAK;EACH,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,QAAQ;EACN,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,UAAU;EACR,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,WAAW;EACT,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACZ,SAAS;IACP,MAAM;IACN,YAAY;IACb;GACF;EACF;CACF;;;;ACnGD,MAAM,mCAAmC;CACvC,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CAChB,WAAW;EACT,MAAM;EACN,OAAO;EACR;CACF;AAED,MAAaA,+BAET"}