@owlmeans/postgres-resource 0.1.15

package/tests/errors.spec.ts

@@ -0,0 +1,121 @@
+import { describe, expect, test } from 'bun:test'
+import { MisshapedRecord, RecordExists, ResourceError } from '@owlmeans/resource'
+
+import {
+  describePgError, PgErrorCode, PostgresCastRequired, PostgresCheckError, PostgresConnectionError,
+  PostgresConstraintError, PostgresDeadlockError, PostgresError, PostgresForeignKeyError,
+  pgErrorToResourceError
+} from '@owlmeans/postgres-resource'
+
+interface DriverShape {
+  code: string
+  message?: string
+  constraint?: string
+  table?: string
+  column?: string
+  detail?: string
+  hint?: string
+  severity?: string
+  where?: string
+}
+
+const driver = (shape: DriverShape): Error => Object.assign(new Error(shape.message ?? 'pg'), shape)
+
+/** What Drizzle raises: its own class, with the driver error hung off `cause`. */
+const wrapped = (shape: DriverShape): Error => {
+  const failure = new Error(`Failed query: insert into "app"."users" ...`)
+  failure.cause = driver(shape)
+  failure.name = 'DrizzleQueryError'
+
+  return failure
+}
+
+describe('@owlmeans/postgres-resource — driver error translation', () => {
+  test('maps every code the resource layer promises a class for', () => {
+    const cases: Array<[string, Function]> = [
+      [PgErrorCode.UniqueViolation, RecordExists],
+      [PgErrorCode.NotNullViolation, MisshapedRecord],
+      [PgErrorCode.ForeignKeyViolation, PostgresForeignKeyError],
+      [PgErrorCode.CheckViolation, PostgresCheckError],
+      [PgErrorCode.DatatypeMismatch, PostgresCastRequired],
+      [PgErrorCode.CannotCoerce, PostgresCastRequired],
+      [PgErrorCode.DeadlockDetected, PostgresDeadlockError]
+    ]
+
+    for (const [code, expected] of cases) {
+      expect(pgErrorToResourceError(driver({ code }))).toBeInstanceOf(expected as never)
+    }
+
+    /** Class prefixes, for the codes with no dedicated class. */
+    expect(pgErrorToResourceError(driver({ code: '08006' }))).toBeInstanceOf(PostgresConnectionError)
+    expect(pgErrorToResourceError(driver({ code: '23P01' }))).toBeInstanceOf(PostgresConstraintError)
+    expect(pgErrorToResourceError(driver({ code: '42P01' }))).toBeInstanceOf(PostgresError)
+  })
+
+  /**
+   * CRUD goes through Drizzle, so the driver error always arrives wrapped. Classifying on
+   * the outer error collapses the whole vocabulary above into one opaque class on exactly
+   * the paths callers use most.
+   */
+  test('classifies a driver error Drizzle has wrapped', () => {
+    const failure = pgErrorToResourceError(wrapped({
+      code: PgErrorCode.UniqueViolation, constraint: 'users_email_key'
+    }))
+
+    expect(failure).toBeInstanceOf(RecordExists)
+    expect(failure.message).toContain(PgErrorCode.UniqueViolation)
+    expect(failure.message).toContain('users_email_key')
+    /** The wrapper is kept as the cause — unwrapping is for classification, not for loss. */
+    expect((failure.cause as Error).name).toBe('DrizzleQueryError')
+  })
+
+  test('leads with the code and never echoes bound parameters', () => {
+    const described = describePgError(wrapped({
+      code: PgErrorCode.UniqueViolation,
+      message: 'duplicate key value violates unique constraint "users_email_key"',
+      constraint: 'users_email_key',
+      table: 'users',
+      column: 'email',
+      detail: 'Key (email)=(a@b.c) already exists.',
+      hint: 'try another',
+      severity: 'ERROR',
+      where: `SQL statement "INSERT INTO users VALUES ('secret')"`
+    }))
+
+    /** The fixer classifies on this text, so the code has to be the first thing in it. */
+    expect(described.startsWith(PgErrorCode.UniqueViolation)).toBe(true)
+    expect(described).toContain('table=users')
+    expect(described).toContain('column=email')
+    expect(described).toContain('hint=try another')
+    /** `where` can quote the statement, and the statement can quote a value. */
+    expect(described).not.toContain('SQL statement')
+  })
+
+  test('passes a framework error through untouched', () => {
+    const original = new ResourceError('already-translated')
+
+    expect(pgErrorToResourceError(original)).toBe(original)
+  })
+
+  test('leaves an error that is not from the driver alone', () => {
+    const plain = new Error('not postgres at all')
+
+    expect(pgErrorToResourceError(plain)).toBe(plain)
+    expect(describePgError(plain)).toBe('not postgres at all')
+    expect(pgErrorToResourceError('a string')).toBeInstanceOf(PostgresError)
+  })
+
+  test('survives a circular cause chain', () => {
+    const outer = new Error('outer') as Error & { cause?: unknown }
+    const inner = new Error('inner') as Error & { cause?: unknown }
+    outer.cause = inner
+    inner.cause = outer
+
+    /**
+     * Returning at all is the assertion — an unbounded walk would spin forever. Note that
+     * `expect(fn).not.toThrow()` cannot say this in Bun: it reports a *returned* `Error` as
+     * a thrown one, and every one of these translations returns exactly that.
+     */
+    expect(pgErrorToResourceError(outer)).toBe(outer)
+  })
+})

package/tests/name.spec.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from 'bun:test'
+import type { DbConfig, ResourceRecord } from '@owlmeans/resource'
+
+import {
+  advisoryKey, assertSqlIdentifier, pgIdentifier, pgTableName, qualify, quoteIdent, quoteLiteral
+} from '@owlmeans/postgres-resource'
+import type { PostgresResource } from '@owlmeans/postgres-resource'
+
+const resource = (alias: string, name?: string): PostgresResource<ResourceRecord> =>
+  ({ alias, ...(name != null ? { name } : {}) }) as PostgresResource<ResourceRecord>
+
+describe('@owlmeans/postgres-resource — identifiers', () => {
+  test('sanitizes an arbitrary name into something Postgres accepts', () => {
+    expect(pgIdentifier('users')).toBe('users')
+    /** Resource aliases carry `-` and `:`; column and table names cannot. */
+    expect(pgIdentifier('wl-profile')).toBe('wl_profile')
+    expect(pgIdentifier('auth:token')).toBe('auth_token')
+    expect(pgIdentifier('9lives')).toBe('_9lives')
+  })
+
+  /**
+   * Postgres truncates past `NAMEDATALEN - 1` server side and says nothing. Truncating here
+   * instead keeps the hash that made the name unique — the shared `dbName()` overflow path
+   * appends its disambiguator past byte 63, where the server would cut it off.
+   */
+  test('keeps an overlong name unique inside the 63 byte limit', () => {
+    const long = 'a'.repeat(200)
+    const identifier = pgIdentifier(long)
+
+    expect(identifier.length).toBe(63)
+    expect(Buffer.byteLength(identifier, 'utf8')).toBeLessThanOrEqual(63)
+    expect(identifier).not.toBe(pgIdentifier(`${long}b`))
+    expect(identifier).toBe(pgIdentifier(long))
+  })
+
+  test('assertSqlIdentifier is the last thing between a config value and injection', () => {
+    expect(assertSqlIdentifier('app_role')).toBe('app_role')
+    expect(() => assertSqlIdentifier('app"; DROP DATABASE x; --')).toThrow(SyntaxError)
+    expect(() => assertSqlIdentifier('has space')).toThrow(SyntaxError)
+    expect(() => assertSqlIdentifier('a'.repeat(64))).toThrow(SyntaxError)
+  })
+
+  test('quotes identifiers and literals', () => {
+    expect(quoteIdent('users')).toBe('"users"')
+    expect(quoteIdent('we"ird')).toBe('"we""ird"')
+    expect(qualify('app', 'users')).toBe('"app"."users"')
+
+    expect(quoteLiteral("O'Brien")).toBe("'O''Brien'")
+    /** No escaping makes a NUL byte safe, so it is refused instead of encoded. */
+    expect(() => quoteLiteral('nul\0byte')).toThrow(SyntaxError)
+  })
+
+  test('derives the physical table name from the resource and its prefix', () => {
+    const config = { service: 'postgres', host: 'localhost' } as DbConfig
+
+    expect(pgTableName(config, resource('wl-profile'))).toBe('wl_profile')
+    /** An explicit `name` wins — the alias may be unusable as an identifier. */
+    expect(pgTableName(config, resource('wl-profile', 'profiles'))).toBe('profiles')
+    expect(pgTableName({ ...config, resourcePrefix: 'app_' }, resource('users'))).toBe('app_users')
+  })
+
+  test('advisory keys are a stable function of the qualified table', () => {
+    const key = advisoryKey('"app"."users"')
+
+    expect(key).toHaveLength(2)
+    expect(key).toEqual(advisoryKey('"app"."users"'))
+    expect(key).not.toEqual(advisoryKey('"app"."posts"'))
+    /** `pg_advisory_lock(int, int)` — anything outside int32 would be rejected by the server. */
+    for (const half of key) {
+      expect(Number.isInteger(half)).toBe(true)
+      expect(half).toBeGreaterThanOrEqual(-2147483648)
+      expect(half).toBeLessThanOrEqual(2147483647)
+    }
+  })
+})

package/tests/schema.spec.ts

@@ -0,0 +1,258 @@
+import { describe, expect, test } from 'bun:test'
+import { UnsupportedArgumentError } from '@owlmeans/resource'
+import type { AnySchema } from 'ajv'
+
+import { schemaToTableSpec, toFormatType } from '@owlmeans/postgres-resource'
+import type { TableSpec } from '@owlmeans/postgres-resource'
+
+/**
+ * Compiling an AJV schema into a table specification is the one step every other part of
+ * the package trusts: DDL emission, drift detection, marshalling and placeholder
+ * resolution all read the result rather than the schema. It needs no database, so it is
+ * covered here rather than behind the integration gate.
+ */
+const compile = (schema: AnySchema, table: string = 'things'): TableSpec =>
+  schemaToTableSpec('things', schema, 'app', table, true)
+
+describe('@owlmeans/postgres-resource — schemaToTableSpec', () => {
+  test('normalizes type spellings to what format_type() reports', () => {
+    expect(toFormatType('varchar(320)')).toBe('character varying(320)')
+    expect(toFormatType('int4')).toBe('integer')
+    expect(toFormatType('int8')).toBe('bigint')
+    expect(toFormatType('timestamptz')).toBe('timestamp with time zone')
+    expect(toFormatType('float8')).toBe('double precision')
+    expect(toFormatType('NUMERIC( 12 , 2 )')).toBe('numeric(12,2)')
+    expect(toFormatType('text[]')).toBe('text[]')
+  })
+
+  test('synthesizes the id primary key when the schema does not declare one', () => {
+    const spec = compile({ type: 'object', properties: { name: { type: 'string' } } } as AnySchema)
+
+    expect(spec.primaryKey).toEqual(['id'])
+    const id = spec.byProperty.id
+    expect(id.sqlType).toBe('text')
+    expect(id.notNull).toBe(true)
+    expect(id.defaultRaw).toBe('gen_random_uuid()::text')
+    /** First, so `SELECT *` and every diff read it where a hand written table would put it. */
+    expect(spec.columns[0].property).toBe('id')
+  })
+
+  test('promotes a declared uuid id to the primary key with a server side default', () => {
+    const spec = compile({
+      type: 'object',
+      properties: { id: { type: 'string', format: 'uuid' }, name: { type: 'string' } },
+      required: ['id', 'name']
+    } as AnySchema)
+
+    expect(spec.primaryKey).toEqual(['id'])
+    expect(spec.byProperty.id.sqlType).toBe('uuid')
+    expect(spec.byProperty.id.defaultRaw).toBe('gen_random_uuid()')
+    expect(spec.qualified).toBe('"app"."things"')
+  })
+
+  test('maps JSON types onto Postgres types', () => {
+    const spec = compile({
+      type: 'object',
+      properties: {
+        plain: { type: 'string' },
+        bounded: { type: 'string', maxLength: 64 },
+        uuid: { type: 'string', format: 'uuid' },
+        stamp: { type: 'string', format: 'date-time' },
+        day: { type: 'string', format: 'date' },
+        blob: { type: 'string', format: 'binary' },
+        small: { type: 'integer' },
+        big: { type: 'integer', maximum: 9007199254740991 },
+        real: { type: 'number' },
+        money: { type: 'number', pg: { precision: 12, scale: 2 } },
+        flag: { type: 'boolean' },
+        payload: { type: 'object' },
+        /** The framework's date convention — an `object` carrying `format: 'date-time'`. */
+        createdAt: { type: 'object', format: 'date-time' },
+        labels: { type: 'array', items: { type: 'string' } },
+        rows: { type: 'array', items: { type: 'object' } }
+      }
+    } as AnySchema)
+
+    const types = Object.fromEntries(spec.columns.map(column => [column.property, column.sqlType]))
+    expect(types).toMatchObject({
+      plain: 'text',
+      bounded: 'character varying(64)',
+      uuid: 'uuid',
+      stamp: 'timestamp with time zone',
+      day: 'date',
+      blob: 'bytea',
+      small: 'integer',
+      big: 'bigint',
+      real: 'double precision',
+      money: 'numeric(12,2)',
+      flag: 'boolean',
+      payload: 'jsonb',
+      createdAt: 'timestamp with time zone',
+      labels: 'text[]',
+      rows: 'jsonb'
+    })
+    expect(spec.byProperty.labels.array).toBe(true)
+    expect(spec.byProperty.rows.array).toBe(false)
+    expect(spec.byProperty.payload.jsonb).toBe(true)
+    expect(spec.byProperty.createdAt.jsonType).toBe('date')
+  })
+
+  /**
+   * Mongo's mapper lost nullability twice, both times on a branch that recomputed it
+   * instead of receiving it — `date-time` and optional objects. Those two shapes are
+   * asserted explicitly, not just the general rule.
+   */
+  test('threads nullability through every branch', () => {
+    const spec = compile({
+      type: 'object',
+      properties: {
+        id: { type: 'string', format: 'uuid' },
+        needed: { type: 'string' },
+        optional: { type: 'string' },
+        nullableStamp: { type: 'object', format: 'date-time', nullable: true },
+        requiredStamp: { type: 'object', format: 'date-time' },
+        optionalObject: { type: 'object' },
+        unionNull: { type: ['string', 'null'] },
+        forcedNull: { type: 'string', pg: { nullable: true } },
+        forcedNotNull: { type: 'string', pg: { nullable: false } }
+      },
+      required: ['id', 'needed', 'requiredStamp', 'unionNull', 'forcedNull', 'forcedNotNull']
+    } as AnySchema)
+
+    const notNull = Object.fromEntries(spec.columns.map(column => [column.property, column.notNull]))
+    expect(notNull).toMatchObject({
+      id: true,
+      needed: true,
+      optional: false,
+      nullableStamp: false,
+      requiredStamp: true,
+      optionalObject: false,
+      unionNull: false,
+      forcedNull: false,
+      forcedNotNull: true
+    })
+  })
+
+  test('applies the pg override vocabulary', () => {
+    const spec = compile({
+      type: 'object',
+      properties: {
+        id: { type: 'string', format: 'uuid' },
+        email: { type: 'string', pg: { type: 'varchar', length: 320, unique: true } },
+        ownerId: {
+          type: 'string',
+          format: 'uuid',
+          pg: { references: { resource: 'users', onDelete: 'cascade' }, index: true }
+        },
+        renamed: { type: 'string', pg: { column: 'renamed_to' } },
+        touched: { type: 'object', format: 'date-time', pg: { defaultRaw: 'now()' } },
+        legacy: { type: 'string', pg: { managed: false } },
+        score: { type: 'integer', pg: { check: '{{col}} >= 0' } }
+      },
+      required: ['id', 'email'],
+      pg: { indexes: [{ name: 'idx_things_email_owner', columns: ['email', 'ownerId'] }] }
+    } as AnySchema)
+
+    expect(spec.byProperty.email.sqlType).toBe('character varying(320)')
+    expect(spec.uniques).toEqual([{ columns: ['email'], name: 'things_email_key' }])
+
+    expect(spec.references).toHaveLength(1)
+    expect(spec.references[0]).toMatchObject({
+      property: 'ownerId', resource: 'users', column: 'id', onDelete: 'cascade',
+      name: 'things_ownerId_fkey'
+    })
+
+    /** No implicit snake_casing anywhere — only an explicit `column` renames. */
+    expect(spec.byProperty.renamed.column).toBe('renamed_to')
+    expect(spec.byColumn.renamed_to.property).toBe('renamed')
+    expect(spec.byProperty.touched.defaultRaw).toBe('now()')
+
+    expect(spec.unmanaged).toContain('legacy')
+    expect(spec.checks.map(check => check.expression)).toContain('"score" >= 0')
+
+    const names = spec.indexes.map(index => index.name)
+    expect(names).toContain('idx_things_email_owner')
+    expect(names).toContain('things_ownerId_idx')
+    /** Index specs address properties; the compiled spec addresses physical columns. */
+    expect(spec.indexes.find(index => index.name === 'idx_things_email_owner')?.columns)
+      .toEqual(['email', 'ownerId'])
+  })
+
+  test('turns a string enum into a CHECK that tolerates NULL when the column does', () => {
+    const spec = compile({
+      type: 'object',
+      properties: {
+        id: { type: 'string', format: 'uuid' },
+        status: { type: 'string', enum: ['active', 'banned'] },
+        mood: { type: 'string', enum: ['ok'], nullable: true }
+      },
+      required: ['id', 'status']
+    } as AnySchema)
+
+    const expressions = spec.checks.map(check => check.expression)
+    expect(expressions).toContain(`"status" IN ('active', 'banned')`)
+    expect(expressions).toContain(`"mood" IS NULL OR "mood" IN ('ok')`)
+  })
+
+  test('flattens allOf composition the way the framework schemas are written', () => {
+    const spec = compile({
+      type: 'object',
+      allOf: [
+        { type: 'object', properties: { id: { type: 'string', format: 'uuid' } }, required: ['id'] },
+        { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] }
+      ],
+      properties: { extra: { type: 'boolean' } }
+    } as AnySchema)
+
+    expect(Object.keys(spec.byProperty).sort()).toEqual(['extra', 'id', 'name'])
+    expect(spec.byProperty.name.notNull).toBe(true)
+    expect(spec.byProperty.extra.notNull).toBe(false)
+  })
+
+  test('honors a composite primary key declared at the root', () => {
+    const spec = compile({
+      type: 'object',
+      properties: {
+        tenant: { type: 'string' },
+        key: { type: 'string' },
+        value: { type: 'string' }
+      },
+      pg: { primaryKey: ['tenant', 'key'] }
+    } as AnySchema)
+
+    expect(spec.primaryKey).toEqual(['tenant', 'key'])
+    expect(spec.byProperty.tenant.notNull).toBe(true)
+    expect(spec.byProperty.key.notNull).toBe(true)
+    /** No id is synthesized once the schema says what identity means. */
+    expect(spec.byProperty.id).toBeUndefined()
+  })
+
+  test('stores a secure field as unbounded text and refuses to make it unique', () => {
+    const spec = compile({
+      type: 'object',
+      properties: { token: { type: 'string', maxLength: 32, secure: true } }
+    } as AnySchema)
+
+    expect(spec.byProperty.token.sqlType).toBe('text')
+    expect(spec.byProperty.token.secure).toBe(true)
+
+    expect(() => compile({
+      type: 'object',
+      properties: { token: { type: 'string', secure: true, pg: { unique: true } } }
+    } as AnySchema)).toThrow(UnsupportedArgumentError)
+  })
+
+  test('rejects an index or key naming a property that does not exist', () => {
+    expect(() => compile({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      pg: { indexes: [{ columns: ['nope'] }] }
+    } as AnySchema)).toThrow(UnsupportedArgumentError)
+
+    expect(() => compile({
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      pg: { primaryKey: ['nope'] }
+    } as AnySchema)).toThrow(UnsupportedArgumentError)
+  })
+})

package/tests/sql.spec.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from 'bun:test'
+import type { BasicContext } from '@owlmeans/context'
+
+import {
+  PostgresPlaceholderError, refOf, resolvePlaceholders, schemaToTableSpec
+} from '@owlmeans/postgres-resource'
+import type { TableSpec } from '@owlmeans/postgres-resource'
+
+const specOf = (alias: string, schema: string, table: string): TableSpec =>
+  schemaToTableSpec(alias, {
+    type: 'object',
+    properties: {
+      id: { type: 'string', format: 'uuid' },
+      email: { type: 'string', pg: { column: 'email_address' } }
+    },
+    required: ['id']
+  } as never, schema, table, true)
+
+/**
+ * The placeholder resolver only ever reads `context.resource(alias).table`, so a literal
+ * stand-in is both sufficient and clearer than booting a context — and it lets the
+ * uninitialized-resource case be constructed at all, which a real context would race.
+ */
+const contextOf = (resources: Record<string, TableSpec | null>): BasicContext<any> => ({
+  resource: (alias: string) => {
+    if (!(alias in resources)) {
+      throw new Error(`unknown:${alias}`)
+    }
+
+    return { table: resources[alias] }
+  }
+} as unknown as BasicContext<any>)
+
+const users = specOf('users', 'app', 'users')
+const posts = specOf('posts', 'app', 'posts')
+const context = contextOf({ users, posts })
+
+describe('@owlmeans/postgres-resource — placeholder resolution', () => {
+  test('resolves the owning resource', () => {
+    expect(resolvePlaceholders('SELECT * FROM {{}}', context, posts))
+      .toBe('SELECT * FROM "app"."posts"')
+    expect(resolvePlaceholders('SELECT * FROM {{ self }}', context, posts))
+      .toBe('SELECT * FROM "app"."posts"')
+  })
+
+  test('resolves another registered resource, its columns, its bare name and its schema', () => {
+    expect(resolvePlaceholders('SELECT * FROM {{users}}', context, posts))
+      .toBe('SELECT * FROM "app"."users"')
+    /** The physical column, not the property — a `pg: { column }` rename has to survive. */
+    expect(resolvePlaceholders('SELECT {{users.email}}', context, posts))
+      .toBe('SELECT "app"."users"."email_address"')
+    expect(resolvePlaceholders('ON CONSTRAINT {{#users}}', context, posts))
+      .toBe('ON CONSTRAINT "users"')
+    expect(resolvePlaceholders('SET search_path = {{$}}', context, posts))
+      .toBe('SET search_path = "app"')
+  })
+
+  test('leaves bound parameters exactly as written', () => {
+    const text = `SELECT * FROM {{}} WHERE "id" = $1 AND "email" = $2 AND note = '{{not-a-placeholder'`
+    expect(resolvePlaceholders(text, context, posts))
+      .toBe(`SELECT * FROM "app"."posts" WHERE "id" = $1 AND "email" = $2 AND note = '{{not-a-placeholder'`)
+  })
+
+  test('refuses an alias it cannot resolve rather than substituting blindly', () => {
+    expect(() => resolvePlaceholders('SELECT * FROM {{nope}}', context, posts))
+      .toThrow(PostgresPlaceholderError)
+    expect(() => resolvePlaceholders('SELECT {{users.nope}}', context, posts))
+      .toThrow(PostgresPlaceholderError)
+    /** Registered but not yet initialized: the table name genuinely isn't known. */
+    expect(() => resolvePlaceholders('SELECT * FROM {{late}}', contextOf({ late: null }), posts))
+      .toThrow(PostgresPlaceholderError)
+  })
+
+  test('refuses a self reference in a query that has no owning resource', () => {
+    expect(() => resolvePlaceholders('SELECT * FROM {{}}', context, null))
+      .toThrow(PostgresPlaceholderError)
+    expect(() => resolvePlaceholders('SET search_path = {{$}}', context, null))
+      .toThrow(PostgresPlaceholderError)
+    /** Other aliases stay addressable — a service level query is scopeless, not blind. */
+    expect(resolvePlaceholders('SELECT * FROM {{users}}', context, null))
+      .toBe('SELECT * FROM "app"."users"')
+  })
+
+  /**
+   * The cache is keyed by context because a layer switch rebuilds every resource against a
+   * different Postgres schema. A service level query has no owning table to key on, so a
+   * process wide cache would hand the next tenant the previous one's table names.
+   */
+  test('does not leak resolved table names between contexts', () => {
+    const tenantA = contextOf({ users: specOf('users', 'tenant_a', 'users') })
+    const tenantB = contextOf({ users: specOf('users', 'tenant_b', 'users') })
+
+    expect(resolvePlaceholders('SELECT * FROM {{users}}', tenantA, null))
+      .toBe('SELECT * FROM "tenant_a"."users"')
+    expect(resolvePlaceholders('SELECT * FROM {{users}}', tenantB, null))
+      .toBe('SELECT * FROM "tenant_b"."users"')
+  })
+
+  test('refOf answers the same question without any SQL around it', () => {
+    expect(refOf(context, posts)).toBe('"app"."posts"')
+    expect(refOf(context, posts, 'users')).toBe('"app"."users"')
+    expect(() => refOf(context, null)).toThrow(PostgresPlaceholderError)
+  })
+})

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"
+  ]
+}