@owlmeans/postgres-resource 0.1.18-rc.40 → 0.1.18-rc.42

package/src/utils/schema.ts

@@ -1,35 +1,15 @@
 import { UnsupportedArgumentError } from '@owlmeans/resource'
 import type { AnySchema } from 'ajv'
+import { logger } from '@owlmeans/log'
 
 import {
   DEF_ID_DEFAULT, DEF_JSON_TYPE, DEF_SQL_TYPE, ID_FIELD, PG_KEYWORD, PgIndexMethod
 } from '../consts.js'
-import type {
-  ColumnJsonType, ColumnSpec, PgCheckSpec, PgIndexSpec, PgPropertyOverride, PgRootOverride,
-  PgReferenceSpec, PgUniqueSpec, TableSpec
-} from '../types.js'
+import type { ColumnJsonType, ColumnSpec, PgCheckSpec, PgIndexSpec, PgPropertyOverride, PgReferenceSpec, PgUniqueSpec, TableSpec } from '../types.js'
 import { pgIdentifier, qualify, quoteIdent } from './name.js'
+import type { RawProperty, RawSchema } from './types.local.js'
 
-interface RawProperty {
-  type?: string | string[]
-  format?: string
-  enum?: unknown[]
-  items?: RawProperty
-  maxLength?: number
-  maximum?: number
-  minimum?: number
-  default?: unknown
-  nullable?: boolean
-  secure?: boolean
-  [PG_KEYWORD]?: PgPropertyOverride
-}
-
-interface RawSchema {
-  properties?: Record<string, RawProperty>
-  required?: string[]
-  allOf?: RawSchema[]
-  [PG_KEYWORD]?: PgRootOverride
-}
+const log = logger('postgres-resource')
 
 const INT32_MAX = 2147483647
 
@@ -244,10 +224,7 @@ const byName = <T extends { name?: string }>(specs: T[], alias: string, kind: st
   for (const spec of specs) {
     const name = spec.name!
     if (seen.has(name)) {
-      console.warn(
-        `@owlmeans/postgres-resource: ${alias} declares ${kind} "${name}" more than once —`
-        + ' keeping the first declaration.'
-      )
+      log.warn('Duplicate declaration, keeping the first one', { resource: alias, kind, name })
       continue
     }
     seen.set(name, spec)
@@ -305,10 +282,9 @@ export const schemaToTableSpec = (
 
     if (override.index != null && override.index !== false) {
       if (column.secure) {
-        console.warn(
-          `@owlmeans/postgres-resource: index on secure column "${alias}.${name}" — encryption`
-          + ' is non-deterministic, so equality lookups through it will never match.'
-        )
+        log.warn('Index on a secure column will never match: encryption is non-deterministic', {
+          resource: alias, column: name,
+        })
       }
       const specs = override.index === true
         ? [{ columns: [name] }]

package/src/utils/sync.ts

@@ -1,23 +1,13 @@
+import { logger } from '@owlmeans/log'
 import type { PoolClient } from 'pg'
 
-import { PgErrorCode } from '../consts.js'
 import { PostgresCastRequired, PostgresSyncError, describePgError, pgErrorToResourceError } from '../errors.js'
 import type { DdlPlan, TableSpec } from '../types.js'
 import { countNonNull } from './introspect.js'
 import { advisoryKey, quoteIdent } from './name.js'
+import { CAST_DATA_CODES } from './consts.local.js'
 
-/**
- * Codes that mean "the cast is legal, the data isn't": a `text` column holding `'a'` retyped to
- * `integer`, a value too wide for the new length, a number past the new range. Postgres refuses
- * each of these rather than truncating, and the remedy is the same one a refused cast needs — so
- * they are only read as a cast problem here, inside DDL. On the CRUD path the identical code means
- * a caller passed a bad value, which is a different bug with a different fix.
- */
-const CAST_DATA_CODES: string[] = [
-  PgErrorCode.InvalidTextRepresentation,
-  PgErrorCode.StringDataRightTruncation,
-  PgErrorCode.NumericValueOutOfRange
-]
+const log = logger('postgres-resource')
 
 /**
  * Serialize initialization across replicas. A session level lock, not `xact`, because
@@ -75,11 +65,9 @@ export const applyPlan = async (
     for (const statement of plan.statements) {
       current = statement.sql
       if (statement.destructive === true && (statement.affected ?? 0) > 0) {
-        console.warn(
-          `@owlmeans/postgres-resource: dropping ${spec.qualified}.${statement.target} —`
-          + ` ${statement.affected} row(s) hold a value. Declare it under \`pg.unmanaged\``
-          + ' or set `pg: { managed: false }` to keep it.'
-        )
+        log.warn('Dropping a column that holds values; declare it under pg.unmanaged or set pg.managed false to keep it', {
+          table: spec.qualified, column: statement.target, rows: statement.affected,
+        }, { event: 'migration.drop' })
       }
       await client.query(statement.sql)
     }

package/src/utils/types.local.ts

@@ -0,0 +1,35 @@
+import type { SQL } from 'drizzle-orm'
+import { PG_KEYWORD } from '../consts.js'
+import type { PgPropertyOverride, PgRootOverride } from '../types.js'
+
+/**
+ * A value at a path, as the jsonb it is (`#>`) and as text (`#>>`). The path is ONE bound `text[]`
+ * parameter, so a segment holding a comma or a brace stays one segment.
+ */
+export interface PathTarget {
+  value: SQL
+  text: SQL
+  /** Absent, or a JSON `null` — what every other store reads as "no value". */
+  missing: SQL
+}
+
+export interface RawProperty {
+  type?: string | string[]
+  format?: string
+  enum?: unknown[]
+  items?: RawProperty
+  maxLength?: number
+  maximum?: number
+  minimum?: number
+  default?: unknown
+  nullable?: boolean
+  secure?: boolean
+  [PG_KEYWORD]?: PgPropertyOverride
+}
+
+export interface RawSchema {
+  properties?: Record<string, RawProperty>
+  required?: string[]
+  allOf?: RawSchema[]
+  [PG_KEYWORD]?: PgRootOverride
+}

package/src/utils/types.ts

@@ -0,0 +1,19 @@
+import type { PgRuntimeTable, TableSpec } from '../types.js'
+import type { MigrationReport } from '@owlmeans/resource'
+import type { BasicContext } from '@owlmeans/context'
+
+export interface TableInit {
+  spec: TableSpec
+  /** The Drizzle table CRUD is built against. */
+  entity: PgRuntimeTable
+  reports: MigrationReport[]
+}
+
+/**
+ * The context a placeholder resolves through.
+ *
+ * Resolution reads exactly one thing — `context.resource(alias).table` — so the config a context
+ * carries is irrelevant here, and pinning one would force every caller holding a server context
+ * to cast its way in. Deliberately open, and named so callers pass what they already have.
+ */
+export type PlaceholderContext = BasicContext<any>

package/tests/diff.spec.ts

@@ -109,3 +109,27 @@ describe('@owlmeans/postgres-resource — comparing a declared definition with t
     }
   })
 })
+
+describe('@owlmeans/postgres-resource — NOT NULL constraints of Postgres 18', () => {
+  test('a not-null constraint row is never planned for a drop', () => {
+    // From 18 every NOT NULL is a pg_constraint row named `<table>_<column>_not_null`. The platform
+    // names its own constraints after the table too, so it took these for its own leftovers and sent
+    // `DROP CONSTRAINT …_id_not_null` — which Postgres refuses on a primary key column.
+    const live: LiveTable = {
+      exists: true,
+      columns: [
+        columnOf({ name: 'id', type: 'text' }),
+        columnOf({ name: 'title', type: 'text', notNull: false }),
+      ],
+      indexes: [],
+      constraints: [
+        { name: 'tasks_id_not_null', type: 'n', definition: 'NOT NULL id' },
+        { name: 'task_entry_id_not_null', type: 'n', definition: 'NOT NULL id' },
+      ],
+    }
+
+    const dropped = planSync(specOf('string'), live).statements.filter(statement => statement.kind === 'drop-constraint')
+    expect(dropped).toEqual([])
+  })
+})
+

package/tests/errors.spec.ts

@@ -97,6 +97,17 @@ describe('@owlmeans/postgres-resource — driver error translation', () => {
     expect(pgErrorToResourceError(original)).toBe(original)
   })
 
+  test('preserves the executed SQL and driver cause for migration diagnostics', () => {
+    const original = driver({ code: '42703', message: 'column o.enquiryId does not exist' })
+    const query = 'UPDATE "app"."opportunity" o SET "enquiryId" = $1 WHERE o."enquiryId" IS NULL'
+    const failure = pgErrorToResourceError(original, query)
+
+    expect(failure).toBeInstanceOf(PostgresError)
+    expect(failure.message).toContain('42703')
+    expect(failure.message).toContain(`SQL: ${query}`)
+    expect(failure.cause).toBe(original)
+  })
+
   test('leaves an error that is not from the driver alone', () => {
     const plain = new Error('not postgres at all')