@prisma-next/adapter-postgres 0.3.0-dev.15 → 0.3.0-dev.162

package/dist/column-types.mjs

@@ -0,0 +1,180 @@
+import { C as SQL_CHAR_CODEC_ID, O as SQL_VARCHAR_CODEC_ID, _ as PG_TIMESTAMPTZ_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIME_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, g as PG_TEXT_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_ENUM_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMP_CODEC_ID, x as PG_VARBIT_CODEC_ID, y as PG_TIMETZ_CODEC_ID } from "./codec-ids-BwjcIf74.mjs";
+
+//#region src/core/standard-schema.ts
+function isObjectLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function resolveOutputJsonSchemaField(schema) {
+	const jsonSchema = schema["~standard"]?.jsonSchema;
+	if (!jsonSchema) return;
+	if (typeof jsonSchema.output === "function") return jsonSchema.output({ target: "draft-07" });
+	return jsonSchema.output;
+}
+function extractStandardSchemaOutputJsonSchema(schema) {
+	const outputSchema = resolveOutputJsonSchemaField(schema);
+	if (!isObjectLike(outputSchema)) return;
+	return outputSchema;
+}
+function extractStandardSchemaTypeExpression(schema) {
+	const expression = schema.expression;
+	if (typeof expression !== "string") return;
+	const trimmedExpression = expression.trim();
+	if (trimmedExpression.length === 0) return;
+	return trimmedExpression;
+}
+function isStandardSchemaLike(value) {
+	return isObjectLike(value) && isObjectLike(value["~standard"]);
+}
+
+//#endregion
+//#region src/exports/column-types.ts
+const textColumn = {
+	codecId: PG_TEXT_CODEC_ID,
+	nativeType: "text"
+};
+function charColumn(length) {
+	return {
+		codecId: SQL_CHAR_CODEC_ID,
+		nativeType: "character",
+		typeParams: { length }
+	};
+}
+function varcharColumn(length) {
+	return {
+		codecId: SQL_VARCHAR_CODEC_ID,
+		nativeType: "character varying",
+		typeParams: { length }
+	};
+}
+const int4Column = {
+	codecId: PG_INT4_CODEC_ID,
+	nativeType: "int4"
+};
+const int2Column = {
+	codecId: PG_INT2_CODEC_ID,
+	nativeType: "int2"
+};
+const int8Column = {
+	codecId: PG_INT8_CODEC_ID,
+	nativeType: "int8"
+};
+const float4Column = {
+	codecId: PG_FLOAT4_CODEC_ID,
+	nativeType: "float4"
+};
+const float8Column = {
+	codecId: PG_FLOAT8_CODEC_ID,
+	nativeType: "float8"
+};
+function numericColumn(precision, scale) {
+	return {
+		codecId: PG_NUMERIC_CODEC_ID,
+		nativeType: "numeric",
+		typeParams: scale === void 0 ? { precision } : {
+			precision,
+			scale
+		}
+	};
+}
+const timestampColumn = {
+	codecId: PG_TIMESTAMP_CODEC_ID,
+	nativeType: "timestamp"
+};
+const timestamptzColumn = {
+	codecId: PG_TIMESTAMPTZ_CODEC_ID,
+	nativeType: "timestamptz"
+};
+function timeColumn(precision) {
+	return {
+		codecId: PG_TIME_CODEC_ID,
+		nativeType: "time",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+function timetzColumn(precision) {
+	return {
+		codecId: PG_TIMETZ_CODEC_ID,
+		nativeType: "timetz",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+const boolColumn = {
+	codecId: PG_BOOL_CODEC_ID,
+	nativeType: "bool"
+};
+function bitColumn(length) {
+	return {
+		codecId: PG_BIT_CODEC_ID,
+		nativeType: "bit",
+		typeParams: { length }
+	};
+}
+function varbitColumn(length) {
+	return {
+		codecId: PG_VARBIT_CODEC_ID,
+		nativeType: "bit varying",
+		typeParams: { length }
+	};
+}
+function intervalColumn(precision) {
+	return {
+		codecId: PG_INTERVAL_CODEC_ID,
+		nativeType: "interval",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+const jsonColumn = {
+	codecId: PG_JSON_CODEC_ID,
+	nativeType: "json"
+};
+const jsonbColumn = {
+	codecId: PG_JSONB_CODEC_ID,
+	nativeType: "jsonb"
+};
+function createJsonTypeParams(schema) {
+	const outputSchema = extractStandardSchemaOutputJsonSchema(schema);
+	if (!outputSchema) throw new Error("JSON schema must expose ~standard.jsonSchema.output()");
+	const expression = extractStandardSchemaTypeExpression(schema);
+	if (expression) return {
+		schemaJson: outputSchema,
+		type: expression
+	};
+	return { schemaJson: outputSchema };
+}
+function createJsonColumnFactory(codecId, nativeType, staticDescriptor) {
+	return (schema) => {
+		if (!schema) return staticDescriptor;
+		if (!isStandardSchemaLike(schema)) throw new Error(`${nativeType}(schema) expects a Standard Schema value`);
+		return {
+			codecId,
+			nativeType,
+			typeParams: createJsonTypeParams(schema)
+		};
+	};
+}
+const _json = createJsonColumnFactory(PG_JSON_CODEC_ID, "json", jsonColumn);
+const _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, "jsonb", jsonbColumn);
+function json(schema) {
+	return _json(schema);
+}
+function jsonb(schema) {
+	return _jsonb(schema);
+}
+function enumType(name, values) {
+	return {
+		codecId: PG_ENUM_CODEC_ID,
+		nativeType: name,
+		typeParams: { values }
+	};
+}
+function enumColumn(typeName, nativeType) {
+	return {
+		codecId: PG_ENUM_CODEC_ID,
+		nativeType,
+		typeRef: typeName
+	};
+}
+
+//#endregion
+export { bitColumn, boolColumn, charColumn, enumColumn, enumType, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, json, jsonColumn, jsonb, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };
+//# sourceMappingURL=column-types.mjs.map

package/dist/column-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-types.mjs","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":["type UnknownRecord = Record<string, unknown>;\n\ntype StandardSchemaJsonSchemaField = {\n  readonly output?: unknown;\n};\n\n/**\n * Runtime view of the Standard Schema protocol.\n * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,\n * and `.expression` for an optional TypeScript type expression string (Arktype-specific).\n *\n * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads\n * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.\n */\nexport type StandardSchemaLike = {\n  readonly '~standard'?: {\n    readonly version?: number;\n    readonly jsonSchema?: StandardSchemaJsonSchemaField;\n  };\n  readonly expression?: unknown;\n};\n\nfunction isObjectLike(value: unknown): value is UnknownRecord {\n  return (typeof value === 'object' || typeof value === 'function') && value !== null;\n}\n\nfunction resolveOutputJsonSchemaField(schema: StandardSchemaLike): unknown {\n  const jsonSchema = schema['~standard']?.jsonSchema;\n  if (!jsonSchema) {\n    return undefined;\n  }\n\n  if (typeof jsonSchema.output === 'function') {\n    return jsonSchema.output({\n      target: 'draft-07',\n    });\n  }\n\n  return jsonSchema.output;\n}\n\nexport function extractStandardSchemaOutputJsonSchema(\n  schema: StandardSchemaLike,\n): UnknownRecord | undefined {\n  const outputSchema = resolveOutputJsonSchemaField(schema);\n  if (!isObjectLike(outputSchema)) {\n    return undefined;\n  }\n\n  return outputSchema;\n}\n\nexport function extractStandardSchemaTypeExpression(\n  schema: StandardSchemaLike,\n): string | undefined {\n  const expression = schema.expression;\n  if (typeof expression !== 'string') {\n    return undefined;\n  }\n\n  const trimmedExpression = expression.trim();\n  if (trimmedExpression.length === 0) {\n    return undefined;\n  }\n\n  return trimmedExpression;\n}\n\nexport function isStandardSchemaLike(value: unknown): value is StandardSchemaLike {\n  return isObjectLike(value) && isObjectLike((value as StandardSchemaLike)['~standard']);\n}\n","/**\n * Column type descriptors for Postgres adapter.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport type { StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '../core/codec-ids';\nimport {\n  extractStandardSchemaOutputJsonSchema,\n  extractStandardSchemaTypeExpression,\n  isStandardSchemaLike,\n  type StandardSchemaLike,\n} from '../core/standard-schema';\n\nexport const textColumn = {\n  codecId: PG_TEXT_CODEC_ID,\n  nativeType: 'text',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function charColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_CHAR_CODEC_ID,\n    nativeType: 'character',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varcharColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_VARCHAR_CODEC_ID,\n    nativeType: 'character varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport const int4Column = {\n  codecId: PG_INT4_CODEC_ID,\n  nativeType: 'int4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int2Column = {\n  codecId: PG_INT2_CODEC_ID,\n  nativeType: 'int2',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int8Column = {\n  codecId: PG_INT8_CODEC_ID,\n  nativeType: 'int8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float4Column = {\n  codecId: PG_FLOAT4_CODEC_ID,\n  nativeType: 'float4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float8Column = {\n  codecId: PG_FLOAT8_CODEC_ID,\n  nativeType: 'float8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function numericColumn(\n  precision: number,\n  scale?: number,\n): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly precision: number; readonly scale?: number };\n} {\n  return {\n    codecId: PG_NUMERIC_CODEC_ID,\n    nativeType: 'numeric',\n    typeParams: scale === undefined ? { precision } : { precision, scale },\n  } as const;\n}\n\nexport const timestampColumn = {\n  codecId: PG_TIMESTAMP_CODEC_ID,\n  nativeType: 'timestamp',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const timestamptzColumn = {\n  codecId: PG_TIMESTAMPTZ_CODEC_ID,\n  nativeType: 'timestamptz',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function timeColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIME_CODEC_ID,\n    nativeType: 'time',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport function timetzColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIMETZ_CODEC_ID,\n    nativeType: 'timetz',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const boolColumn = {\n  codecId: PG_BOOL_CODEC_ID,\n  nativeType: 'bool',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function bitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_BIT_CODEC_ID,\n    nativeType: 'bit',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varbitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_VARBIT_CODEC_ID,\n    nativeType: 'bit varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport function intervalColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_INTERVAL_CODEC_ID,\n    nativeType: 'interval',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const jsonColumn = {\n  codecId: PG_JSON_CODEC_ID,\n  nativeType: 'json',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const jsonbColumn = {\n  codecId: PG_JSONB_CODEC_ID,\n  nativeType: 'jsonb',\n} as const satisfies ColumnTypeDescriptor;\n\ntype JsonSchemaTypeParams = {\n  readonly schemaJson: Record<string, unknown>;\n  readonly type?: string;\n};\n\nfunction createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {\n  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);\n  if (!outputSchema) {\n    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');\n  }\n\n  const expression = extractStandardSchemaTypeExpression(schema);\n  if (expression) {\n    return { schemaJson: outputSchema, type: expression };\n  }\n\n  return { schemaJson: outputSchema };\n}\n\nfunction createJsonColumnFactory(\n  codecId: string,\n  nativeType: string,\n  staticDescriptor: ColumnTypeDescriptor,\n) {\n  return (schema?: StandardSchemaLike): ColumnTypeDescriptor => {\n    if (!schema) {\n      return staticDescriptor;\n    }\n\n    if (!isStandardSchemaLike(schema)) {\n      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);\n    }\n\n    return {\n      codecId,\n      nativeType,\n      typeParams: createJsonTypeParams(schema),\n    };\n  };\n}\n\nconst _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);\nconst _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);\n\nexport function json(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _json(schema);\n}\n\nexport function jsonb(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _jsonb(schema);\n}\n\nexport function enumType<const Values extends readonly string[]>(\n  name: string,\n  values: Values,\n): StorageTypeInstance & { readonly typeParams: { readonly values: Values } } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType: name,\n    typeParams: { values },\n  } as const;\n}\n\nexport function enumColumn<TypeName extends string>(\n  typeName: TypeName,\n  nativeType: string,\n): ColumnTypeDescriptor & { readonly typeRef: TypeName } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType,\n    typeRef: typeName,\n  };\n}\n"],"mappings":"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"}

package/dist/control.d.mts

@@ -0,0 +1,77 @@
+import { ColumnDefault } from "@prisma-next/contract/types";
+import { SqlControlAdapterDescriptor } from "@prisma-next/family-sql/control";
+
+//#region src/core/sql-utils.d.ts
+
+/**
+ * Shared SQL utility functions for the Postgres adapter.
+ *
+ * These functions handle safe SQL identifier and literal escaping
+ * with security validations to prevent injection and encoding issues.
+ */
+/**
+ * Error thrown when an invalid SQL identifier or literal is detected.
+ * Boundary layers map this to structured envelopes.
+ */
+declare class SqlEscapeError extends Error {
+  readonly value: string;
+  readonly kind: 'identifier' | 'literal';
+  constructor(message: string, value: string, kind: 'identifier' | 'literal');
+}
+/**
+ * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ * - Rejects empty identifiers
+ * - Warns on identifiers exceeding PostgreSQL's 63-character limit
+ *
+ * @throws {SqlEscapeError} If the identifier contains null bytes or is empty
+ */
+declare function quoteIdentifier(identifier: string): string;
+/**
+ * Escapes a string literal for safe use in SQL statements.
+ *
+ * Security validations:
+ * - Rejects null bytes which could cause truncation or unexpected behavior
+ *
+ * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
+ * Backslashes are treated as literal characters, not escape sequences.
+ *
+ * @throws {SqlEscapeError} If the value contains null bytes
+ */
+declare function escapeLiteral(value: string): string;
+/**
+ * Builds a qualified name (schema.object) with proper quoting.
+ */
+declare function qualifyName(schemaName: string, objectName: string): string;
+//#endregion
+//#region src/core/default-normalizer.d.ts
+/**
+ * Parses a raw Postgres column default expression into a normalized ColumnDefault.
+ * This enables semantic comparison between contract defaults and introspected schema defaults.
+ *
+ * Used by the migration diff layer to normalize raw database defaults during comparison,
+ * keeping the introspection layer focused on faithful data capture.
+ *
+ * @param rawDefault - Raw default expression from information_schema.columns.column_default
+ * @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)
+ * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
+ */
+declare function parsePostgresDefault(rawDefault: string, nativeType?: string): ColumnDefault | undefined;
+//#endregion
+//#region src/core/control-adapter.d.ts
+
+/**
+ * Normalizes a Postgres schema native type to its canonical form for comparison.
+ *
+ * Uses a pre-computed lookup map for simple prefix replacements (O(1))
+ * and handles complex temporal type normalization separately.
+ */
+declare function normalizeSchemaNativeType(nativeType: string): string;
+//#endregion
+//#region src/exports/control.d.ts
+declare const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'>;
+//#endregion
+export { SqlEscapeError, postgresAdapterDescriptor as default, escapeLiteral, normalizeSchemaNativeType, parsePostgresDefault, qualifyName, quoteIdentifier };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/sql-utils.ts","../src/core/default-normalizer.ts","../src/core/control-adapter.ts","../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAWA;AA0BA;AAiCA;AAcA;;;cAzEa,cAAA,SAAuB,KAAA;ECuDpB,SAAA,KAAA,EAAA,MAAA;;;;ACsZhB;;;;AC/cgG;;;;;;iBH4BhF,eAAA;;;;;;;;;;;;iBAiCA,aAAA;;;;iBAcA,WAAA;;;;;;AAzEhB;AA0BA;AAiCA;AAcA;;;;AClBA;iBAAgB,oBAAA,2CAGb;;;;;;;;;;iBCmZa,yBAAA;;;cC7cV,2BAA2B"}