@owlmeans/postgres 0.1.15

package/tests/custom-sql.spec.ts

@@ -0,0 +1,196 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { makePostgresResource, PostgresPlaceholderError } from '@owlmeans/postgres-resource'
+import type { PostgresResource } from '@owlmeans/postgres-resource'
+import type { ResourceRecord } from '@owlmeans/resource'
+
+import { gate, makeSuite } from './context.js'
+import type { PostgresService } from './context.js'
+
+interface Author extends ResourceRecord {
+  id?: string
+  name: string
+  email?: string
+}
+
+interface Book extends ResourceRecord {
+  id?: string
+  authorId: string
+  title: string
+  price?: number
+  meta?: Record<string, unknown>
+}
+
+const authorSchema = {
+  type: 'object',
+  properties: {
+    id: { type: 'string', format: 'uuid' },
+    name: { type: 'string' },
+    /** Renamed on purpose — every placeholder form has to emit the *physical* column. */
+    email: { type: 'string', nullable: true, pg: { column: 'email_address' } }
+  },
+  required: ['id', 'name']
+} as never
+
+const bookSchema = {
+  type: 'object',
+  properties: {
+    id: { type: 'string', format: 'uuid' },
+    authorId: { type: 'string', format: 'uuid', pg: { references: { resource: 'sql-authors' } } },
+    title: { type: 'string' },
+    price: { type: 'number', nullable: true },
+    meta: { type: 'object', nullable: true }
+  },
+  required: ['id', 'authorId', 'title']
+} as never
+
+/** The value every one of these specs is really about: it must never become SQL. */
+const HOSTILE = `'); DROP TABLE "sql_books"; --`
+
+const suite = makeSuite('sql')
+const it = gate.skip ? test.skip : test
+
+describe('@owlmeans/postgres — custom SQL with alias placeholders', () => {
+  if (gate.skip) {
+    test.skip(gate.reason ?? 'postgres gate closed', () => {})
+
+    return
+  }
+
+  let pg: PostgresService
+  let authors: PostgresResource<Author>
+  let books: PostgresResource<Book>
+  let tolkien: Author
+
+  beforeAll(async () => {
+    const author = makePostgresResource<Author, PostgresResource<Author>>('sql-authors')
+    author.schema = authorSchema
+    const book = makePostgresResource<Book, PostgresResource<Book>>('sql-books')
+    book.schema = bookSchema
+
+    const booted = await suite.boot({ resources: [author, book] })
+    pg = booted.pg
+    authors = booted.context.resource<PostgresResource<Author>>('sql-authors')
+    books = booted.context.resource<PostgresResource<Book>>('sql-books')
+
+    tolkien = await authors.create({ name: 'Tolkien', email: 'jrr@shire.me' })
+    await books.create({ authorId: tolkien.id as string, title: 'The Hobbit', price: 9.5 })
+    await books.create({
+      authorId: tolkien.id as string, title: 'The Silmarillion', price: 14, meta: { posthumous: true }
+    })
+  })
+
+  afterAll(async () => {
+    await suite.teardown()
+  })
+
+  it('answers the same qualified name through every route to it', () => {
+    const qualified = `"${suite.schema}"."sql_authors"`
+
+    expect(authors.ref()).toBe(qualified)
+    expect(authors.table.qualified).toBe(qualified)
+    expect(books.ref('sql-authors')).toBe(qualified)
+    expect(pg.qualify('sql-authors')).toBe(qualified)
+  })
+
+  it('substitutes the table, its columns, its bare name and its schema', async () => {
+    const [row] = await books.query<{ title: string, author: string }>(
+      `SELECT {{sql-books.title}} AS title, {{sql-authors.name}} AS author
+         FROM {{}} JOIN {{sql-authors}} ON {{sql-books.authorId}} = {{sql-authors.id}}
+        WHERE {{sql-books.title}} = $1`,
+      ['The Hobbit']
+    )
+
+    expect(row).toEqual({ title: 'The Hobbit', author: 'Tolkien' })
+
+    /** `{{$}}` and `{{#alias}}` compose into the same reference `{{alias}}` emits. */
+    const [counted] = await books.query<{ n: number }>('SELECT count(*)::int AS n FROM {{$}}.{{#sql-books}}')
+    expect(counted.n).toBe(2)
+  })
+
+  it('emits the physical column a property was renamed to', async () => {
+    const [row] = await authors.query<{ email_address: string }>(
+      'SELECT {{sql-authors.email}} FROM {{}} WHERE "name" = $1', ['Tolkien']
+    )
+
+    /** The property is `email`; nothing but `email_address` exists in the database. */
+    expect(row.email_address).toBe('jrr@shire.me')
+    await expect(authors.query('SELECT {{sql-authors.emailAddress}} FROM {{}}'))
+      .rejects.toThrow(PostgresPlaceholderError)
+  })
+
+  it('keeps values in parameters, never in the statement', async () => {
+    const created = await authors.create({ name: HOSTILE })
+
+    const [row] = await authors.query<{ name: string }>(
+      'SELECT "name" FROM {{}} WHERE "id" = $1', [created.id]
+    )
+    expect(row.name).toBe(HOSTILE)
+
+    /** The statement the value tried to become would have dropped this table. */
+    const [alive] = await books.query<{ n: number }>('SELECT count(*)::int AS n FROM {{}}')
+    expect(alive.n).toBe(2)
+
+    await authors.delete(created.id as string)
+  })
+
+  it('marshals through select where query hands back the raw row', async () => {
+    const raw = await authors.queryOne<{ email_address: string, email?: string }>(
+      'SELECT * FROM {{}} WHERE "name" = $1', ['Tolkien']
+    )
+    expect(raw?.email_address).toBe('jrr@shire.me')
+    expect(raw?.email).toBeUndefined()
+
+    const record = await authors.selectOne<Author>('SELECT * FROM {{}} WHERE "name" = $1', ['Tolkien'])
+    expect(record?.email).toBe('jrr@shire.me')
+    expect(record?.id).toBe(tolkien.id as string)
+
+    /** jsonb comes back parsed, not as a string, on both routes. */
+    const [book] = await books.select<Book>(`SELECT * FROM {{}} WHERE "title" = $1`, ['The Silmarillion'])
+    expect(book.meta).toEqual({ posthumous: true })
+  })
+
+  it('reports affected rows from execute', async () => {
+    expect(await books.execute('UPDATE {{}} SET "price" = "price" + $1', [1])).toBe(2)
+    expect(await books.execute('UPDATE {{}} SET "price" = $1 WHERE "title" = $2', [10.5, 'The Hobbit'])).toBe(1)
+    expect(await books.execute('UPDATE {{}} SET "price" = $1 WHERE "title" = $2', [0, 'Nothing'])).toBe(0)
+  })
+
+  it('refuses an alias it cannot resolve instead of emitting it', async () => {
+    await expect(books.query('SELECT * FROM {{ghosts}}')).rejects.toThrow(PostgresPlaceholderError)
+    /** A service level query is scopeless — it has no owning table for `{{}}` to mean. */
+    await expect(pg.query('SELECT * FROM {{}}')).rejects.toThrow(PostgresPlaceholderError)
+    expect(await pg.query('SELECT count(*)::int AS n FROM {{sql-books}}')).toEqual([{ n: 2 }])
+  })
+
+  it('commits a transaction and rolls back a failed one', async () => {
+    const added = await books.transaction(async tx => {
+      await tx.execute('INSERT INTO {{}} ("authorId", "title") VALUES ($1, $2)', [tolkien.id, 'Unfinished Tales'])
+
+      return await tx.queryOne<{ n: number }>('SELECT count(*)::int AS n FROM {{}}')
+    })
+    expect(added?.n).toBe(3)
+    expect(await books.count()).toBe(3)
+
+    await expect(books.transaction(async tx => {
+      await tx.execute('DELETE FROM {{}}')
+      expect(tx.ref()).toBe(`"${suite.schema}"."sql_books"`)
+      expect(tx.ref('sql-authors')).toBe(`"${suite.schema}"."sql_authors"`)
+
+      throw new Error('deliberate')
+    })).rejects.toThrow('deliberate')
+
+    /** Nothing the transaction did survives it. */
+    expect(await books.count()).toBe(3)
+  })
+
+  it('exposes the same transaction façade at service level', async () => {
+    const total = await pg.transaction(async tx => {
+      await tx.execute('DELETE FROM {{sql-books}} WHERE "title" = $1', ['Unfinished Tales'])
+
+      return await tx.query<{ n: number }>('SELECT count(*)::int AS n FROM {{sql-books}}')
+    })
+
+    expect(total).toEqual([{ n: 2 }])
+    expect(await books.count()).toBe(2)
+  })
+})

package/tests/migration.spec.ts

@@ -0,0 +1,260 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { makePostgresResource, resetDeclarations } from '@owlmeans/postgres-resource'
+import type { PostgresResource, PostgresTx } from '@owlmeans/postgres-resource'
+import { MigrationConflict, MigrationError, MigrationStage } from '@owlmeans/resource'
+import type { ResourceRecord } from '@owlmeans/resource'
+
+import { gate, ledgerOf, makeSuite, raw, shapeOf } from './context.js'
+import type { LedgerRow, PostgresService } from './context.js'
+
+interface Note extends ResourceRecord {
+  id?: string
+  title?: string
+  slug?: string
+  note?: string
+}
+
+const noteSchema = (extra: Record<string, unknown> = {}, required: string[] = []): unknown => ({
+  type: 'object',
+  properties: {
+    id: { type: 'string', format: 'uuid' },
+    title: { type: 'string', nullable: true },
+    ...extra
+  },
+  required: ['id', ...required]
+})
+
+/**
+ * Migration bodies live at module scope because the checksum hashes their source text: two
+ * inline arrow functions that happen to read the same are the same migration, and two that
+ * differ by a space are a conflict. Naming them makes both facts deliberate.
+ */
+const ran: Record<string, number> = {}
+const tick = (name: string): void => { ran[name] = (ran[name] ?? 0) + 1 }
+
+/** Would fail with `42P01` if it ever ran — the table does not exist yet at pre stage. */
+const ghostBody = async (tx: PostgresTx): Promise<void> => {
+  tick('ghost')
+  await tx.execute('ALTER TABLE {{}} ADD COLUMN "ghost" text')
+}
+
+const seedBody = async (tx: PostgresTx): Promise<void> => {
+  tick('seed')
+  await tx.execute('INSERT INTO {{}} ("title") VALUES ($1)', ['seeded'])
+}
+
+/** Adds and backfills the column reconciliation is about to demand `NOT NULL` on. */
+const slugBody = async (tx: PostgresTx): Promise<void> => {
+  tick('slug')
+  await tx.execute('ALTER TABLE {{}} ADD COLUMN "slug" text')
+  await tx.execute(`UPDATE {{}} SET "slug" = 'backfilled' WHERE "slug" IS NULL`)
+}
+
+/** Writes into a column reconciliation has only just created. */
+const noteBody = async (tx: PostgresTx): Promise<void> => {
+  tick('note')
+  await tx.execute(`UPDATE {{}} SET "note" = 'seen'`)
+}
+
+const failingBody = async (): Promise<void> => {
+  tick('failing')
+  throw new Error('deliberate')
+}
+
+const driftBody = async (tx: PostgresTx): Promise<void> => { await tx.execute('SELECT 1') }
+const driftEdited = async (tx: PostgresTx): Promise<void> => { await tx.execute('SELECT 2') }
+
+const copyBody = async (tx: PostgresTx): Promise<void> => {
+  tick('copy')
+  await tx.execute('INSERT INTO {{}} ("title") SELECT "title" FROM {{mig-src}}')
+}
+
+const suite = makeSuite('migration')
+const it = gate.skip ? test.skip : test
+
+interface Built {
+  alias: string
+  declare?: (resource: PostgresResource<Note>) => void
+  schema?: unknown
+}
+
+const build = (spec: Built): PostgresResource<Note> => {
+  const resource = makePostgresResource<Note, PostgresResource<Note>>(spec.alias)
+  resource.schema = (spec.schema ?? noteSchema()) as never
+  spec.declare?.(resource)
+
+  return resource
+}
+
+const boot = async (...specs: Built[]): Promise<PostgresService> =>
+  (await suite.boot({ resources: specs.map(build) })).pg
+
+const ledger = async (pg: PostgresService, alias: string): Promise<LedgerRow[]> =>
+  (await ledgerOf(pg, suite.schema)).filter(row => row.alias === alias)
+
+describe('@owlmeans/postgres — code registered migrations', () => {
+  if (gate.skip) {
+    test.skip(gate.reason ?? 'postgres gate closed', () => {})
+
+    return
+  }
+
+  afterAll(async () => {
+    await suite.teardown()
+  })
+
+  /**
+   * A migration that reproduces a shape the current schema already produces must not be
+   * replayed against a table that was just created with that shape. Here the proof is
+   * blunt: `ghostBody` targets a table that does not exist at pre stage, so replaying it
+   * would abort the boot outright.
+   */
+  it('baselines every migration on a table it just created', async () => {
+    const pg = await boot({
+      alias: 'mig-a',
+      declare: resource => {
+        resource.migration('0001-ghost', ghostBody)
+        resource.migration('0002-seed', seedBody, MigrationStage.Post)
+      }
+    })
+
+    const rows = await ledger(pg, 'mig-a')
+    expect(rows.map(row => row.name)).toEqual(['0001-ghost', '0002-seed'])
+    expect(rows.every(row => row.baseline)).toBe(true)
+    /** Baselining covers both stages in one write, so the recorded stage is the declared one. */
+    expect(rows.map(row => row.stage)).toEqual(['pre', 'post'])
+
+    expect(ran.ghost).toBeUndefined()
+    expect(ran.seed).toBeUndefined()
+    expect(Object.keys(await shapeOf(pg, suite.schema, 'mig_a'))).not.toContain('ghost')
+  })
+
+  it('skips what the ledger already records on the next boot', async () => {
+    const pg = await boot({
+      alias: 'mig-a',
+      declare: resource => {
+        resource.migration('0001-ghost', ghostBody)
+        resource.migration('0002-seed', seedBody, MigrationStage.Post)
+      }
+    })
+
+    expect(ran.ghost).toBeUndefined()
+    expect(ran.seed).toBeUndefined()
+    expect(await ledger(pg, 'mig-a')).toHaveLength(2)
+  })
+
+  it('applies a migration added after the table exists, exactly once', async () => {
+    await boot({ alias: 'mig-b' })
+    expect(await ledger(await boot({ alias: 'mig-b' }), 'mig-b')).toHaveLength(0)
+
+    const applied = await boot({
+      alias: 'mig-b',
+      declare: resource => { resource.migration('0001-seed', seedBody, MigrationStage.Post) }
+    })
+
+    expect(ran.seed).toBe(1)
+    const rows = await ledger(applied, 'mig-b')
+    expect(rows).toHaveLength(1)
+    /** Applied, not baselined — the distinction is what makes a replay detectable. */
+    expect(rows[0].baseline).toBe(false)
+
+    /** Re-registering an identical body is a no-op, so this boot has the same registry. */
+    const again = await boot({
+      alias: 'mig-b',
+      declare: resource => { resource.migration('0001-seed', seedBody, MigrationStage.Post) }
+    })
+
+    expect(ran.seed).toBe(1)
+    expect(await ledger(again, 'mig-b')).toHaveLength(1)
+    expect(await again.query('SELECT count(*)::int AS n FROM {{mig-b}}')).toEqual([{ n: 1 }])
+  })
+
+  /**
+   * Both stages in one boot, each doing something the other stage could not: `slug` has to
+   * exist and be backfilled *before* reconciliation demands `NOT NULL` on it, and `note`
+   * cannot be written to until reconciliation has created it.
+   */
+  it('runs pre migrations before reconciliation and post migrations after it', async () => {
+    const before = await boot({ alias: 'mig-c' })
+    await before.query('INSERT INTO {{mig-c}} ("title") VALUES ($1)', ['existing'])
+
+    const pg = await boot({
+      alias: 'mig-c',
+      schema: noteSchema({ slug: { type: 'string' }, note: { type: 'string', nullable: true } }, ['slug']),
+      declare: resource => {
+        resource.migration('0001-slug', slugBody)
+        resource.migration('0002-note', noteBody, MigrationStage.Post)
+      }
+    })
+
+    expect(ran.slug).toBe(1)
+    expect(ran.note).toBe(1)
+
+    const shape = await shapeOf(pg, suite.schema, 'mig_c')
+    expect(shape.slug).toBe('text NOT NULL')
+    expect(shape.note).toBe('text')
+
+    expect(await pg.query('SELECT "title", "slug", "note" FROM {{mig-c}}'))
+      .toEqual([{ title: 'existing', slug: 'backfilled', note: 'seen' }])
+  })
+
+  it('aborts initialization when a migration throws, and records nothing', async () => {
+    await boot({ alias: 'mig-d' })
+
+    await expect(boot({
+      alias: 'mig-d',
+      declare: resource => { resource.migration('0001-boom', failingBody, MigrationStage.Post) }
+    })).rejects.toThrow(MigrationError)
+
+    expect(ran.failing).toBe(1)
+    /** The context never came up, so the ledger has to be read outside it. */
+    const rows = await raw(async pool => (await pool.query<{ name: string }>(
+      `SELECT "name" FROM "${suite.schema}"."_owlmeans_migrations" WHERE "alias" = $1`, ['mig-d']
+    )).rows)
+    expect(rows).toHaveLength(0)
+  })
+
+  it('refuses to start when an applied migration body has been edited', async () => {
+    await boot({ alias: 'mig-e' })
+    await boot({
+      alias: 'mig-e',
+      declare: resource => { resource.migration('0001-drift', driftBody, MigrationStage.Post) }
+    })
+
+    /** A restarted process with an edited source file — the registry has to be rebuilt. */
+    resetDeclarations('mig-e')
+
+    await expect(boot({
+      alias: 'mig-e',
+      declare: resource => { resource.migration('0001-drift', driftEdited, MigrationStage.Post) }
+    })).rejects.toThrow(MigrationConflict)
+  })
+
+  it('rejects a changed body under a name already registered in this process', () => {
+    resetDeclarations('mig-conflict')
+    const resource = makePostgresResource<Note, PostgresResource<Note>>('mig-conflict')
+    resource.migration('0001-drift', driftBody)
+
+    expect(() => resource.migration('0001-drift', driftEdited)).toThrow(MigrationConflict)
+    /** Identical re-registration is routine — every context switch re-runs the maker. */
+    expect(() => resource.migration('0001-drift', driftBody)).not.toThrow()
+  })
+
+  /**
+   * Registration order matters here where it doesn't for foreign keys: a key is deferred
+   * until every resource has initialized, but a migration runs inside its own resource's
+   * `init()`, so an alias it names has to have been initialized already.
+   */
+  it('resolves another resource by alias inside a migration', async () => {
+    const pg = await boot({ alias: 'mig-src' }, { alias: 'mig-f' })
+    await pg.query('INSERT INTO {{mig-src}} ("title") VALUES ($1)', ['copied'])
+
+    const applied = await boot({ alias: 'mig-src' }, {
+      alias: 'mig-f',
+      declare: resource => { resource.migration('0001-copy', copyBody, MigrationStage.Post) }
+    })
+
+    expect(ran.copy).toBe(1)
+    expect(await applied.query('SELECT "title" FROM {{mig-f}}')).toEqual([{ title: 'copied' }])
+  })
+})

package/tests/sync.spec.ts

@@ -0,0 +1,156 @@
+import { afterAll, describe, expect, test } from 'bun:test'
+import { makePostgresResource, PgAutoSync, PostgresCastRequired } from '@owlmeans/postgres-resource'
+import type { PostgresResource } from '@owlmeans/postgres-resource'
+import type { ResourceRecord } from '@owlmeans/resource'
+
+import { gate, makeSuite, shapeOf } from './context.js'
+import type { PostgresService } from '@owlmeans/postgres'
+
+interface Thing extends ResourceRecord {
+  id?: string
+  name?: string
+}
+
+const v1 = {
+  type: 'object',
+  properties: {
+    id: { type: 'string', format: 'uuid' },
+    name: { type: 'string' },
+    hits: { type: 'integer', nullable: true },
+    legacy: { type: 'string', nullable: true }
+  },
+  required: ['id', 'name']
+}
+
+/** `hits` widens to bigint, `name` gains a length, `note` appears, `legacy` disappears. */
+const v2 = {
+  type: 'object',
+  properties: {
+    id: { type: 'string', format: 'uuid' },
+    name: { type: 'string', pg: { type: 'varchar', length: 100 } },
+    hits: { type: 'integer', nullable: true, pg: { type: 'bigint' } },
+    note: { type: 'string', nullable: true }
+  },
+  required: ['id', 'name']
+}
+
+/** `name` text → integer, with `'a'` already stored: the cast is legal, the data is not. */
+const v3 = {
+  type: 'object',
+  properties: {
+    id: { type: 'string', format: 'uuid' },
+    name: { type: 'integer' }
+  },
+  required: ['id', 'name']
+}
+
+const suite = makeSuite('sync')
+const it = gate.skip ? test.skip : test
+
+const boot = async (autoSync: PgAutoSync, schema: unknown): Promise<PostgresService> => {
+  const thing = makePostgresResource<Thing, PostgresResource<Thing>>('sync-things')
+  thing.schema = schema as never
+
+  return (await suite.boot({ autoSync, resources: [thing] })).pg
+}
+
+const shape = async (pg: PostgresService): Promise<Record<string, string>> =>
+  await shapeOf(pg, suite.schema, 'sync_things')
+
+describe('@owlmeans/postgres — structure reconciliation', () => {
+  if (gate.skip) {
+    test.skip(gate.reason ?? 'postgres gate closed', () => {})
+
+    return
+  }
+
+  afterAll(async () => {
+    await suite.teardown()
+  })
+
+  it('creates the table on the first boot', async () => {
+    const pg = await boot(PgAutoSync.Full, v1)
+
+    expect(await shape(pg)).toEqual({
+      id: 'uuid NOT NULL',
+      name: 'text NOT NULL',
+      hits: 'integer',
+      legacy: 'text'
+    })
+
+    await pg.query(
+      `INSERT INTO {{sync-things}} ("name", "hits", "legacy") VALUES ($1, $2, $3)`, ['a', 1, 'keep']
+    )
+  })
+
+  /**
+   * The adoption path for a table this package did not create: converge what is missing
+   * without touching what is there, verify the plan comes out empty, then flip to `full`.
+   */
+  it('additive adds columns but never retypes and never drops', async () => {
+    const additive = await shape(await boot(PgAutoSync.Additive, v2))
+
+    expect(additive.note).toBe('text')
+    expect(additive.legacy).toBe('text')
+    expect(additive.hits).toBe('integer')
+    expect(additive.name).toBe('text NOT NULL')
+  })
+
+  it('full drops, retypes and tightens — and the rows survive', async () => {
+    const pg = await boot(PgAutoSync.Full, v2)
+    const full = await shape(pg)
+
+    expect(full.legacy).toBeUndefined()
+    expect(full.hits).toBe('bigint')
+    expect(full.name).toBe('character varying(100) NOT NULL')
+
+    const rows = await pg.query<{ name: string, hits: string | number }>(
+      `SELECT "name", "hits" FROM {{sync-things}}`
+    )
+    expect(rows).toHaveLength(1)
+    expect(rows[0].name).toBe('a')
+  })
+
+  it('off reconciles nothing at all', async () => {
+    /** v1 declares `legacy` and no `note`; with sync off the table keeps its v2 shape. */
+    const off = await shape(await boot(PgAutoSync.Off, v1))
+
+    expect(off.note).toBe('text')
+    expect(off.legacy).toBeUndefined()
+  })
+
+  it('refuses an unsafe cast instead of truncating, and rolls the whole plan back', async () => {
+    const before = await shape(await boot(PgAutoSync.Off, v2))
+
+    await expect(boot(PgAutoSync.Full, v3)).rejects.toThrow(PostgresCastRequired)
+
+    /** DDL runs in one transaction, so a refused step leaves nothing half applied. */
+    expect(await shape(await boot(PgAutoSync.Off, v2))).toEqual(before)
+  })
+
+  it('names the escape hatch in the message it raises', async () => {
+    const failure = await boot(PgAutoSync.Full, v3).catch((error: Error) => error)
+
+    expect(failure).toBeInstanceOf(PostgresCastRequired)
+    expect((failure as Error).message).toContain('using')
+    expect((failure as Error).message).toContain('ALTER TABLE')
+  })
+
+  it('refuses a cast Postgres has no entry for at all', async () => {
+    const flag = {
+      type: 'object',
+      properties: { id: { type: 'string', format: 'uuid' }, flag: { type: 'boolean', nullable: true } },
+      required: ['id']
+    }
+    await boot(PgAutoSync.Full, flag)
+
+    /** boolean → timestamptz: no registered cast, so it fails on an empty column too. */
+    await expect(boot(PgAutoSync.Full, {
+      ...flag,
+      properties: {
+        ...flag.properties,
+        flag: { type: 'object', format: 'date-time', nullable: true }
+      }
+    })).rejects.toThrow(PostgresCastRequired)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": [
+    "@owlmeans/dep-config/tsconfig.base.json",
+    "@owlmeans/dep-config/tsconfig.node.json"
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/",
+    "outDir": "./build/"
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./tests/**/*",
+    "./*.ts"
+  ]
+}