@juit/pgproxy-utils 1.0.0

package/src/extract.ts

@@ -0,0 +1,137 @@
+import { PGClient } from '@juit/pgproxy-client'
+import '@juit/pgproxy-client-psql'
+
+import type { Schema } from './index'
+
+/* ========================================================================== *
+ * INTERNALS                                                                  *
+ * ========================================================================== */
+
+/** Master query to analyse the structure of our database */
+const query = `
+  SELECT
+    "c"."table_schema" AS "schema",
+    "c"."table_name" AS "table",
+    "c"."column_name" AS "column",
+    "c"."is_nullable"::bool AS "isNullable",
+    CASE WHEN "c"."column_default" IS NULL
+      THEN false
+      ELSE true
+    END AS "hasDefault",
+    "t"."oid" AS "oid",
+    "e"."enumValues" AS "enumValues",
+    "d"."description" AS "description"
+  FROM
+    "information_schema"."columns" AS "c"
+  -- join the pg_catalog.pg_type to bring in the OIDs
+  INNER JOIN
+    "pg_catalog"."pg_type" AS "t"
+  ON
+    "c"."udt_name" = "t"."typname"
+  -- join the pg_catalog.pg_statio_all_tables to bring in the OBJIDs
+  INNER JOIN
+    "pg_catalog"."pg_statio_all_tables" AS "s"
+  ON
+    "c"."table_schema" = "s"."schemaname" AND
+    "c"."table_name"   = "s"."relname"
+  -- join the pg_catalog.pg_enum to bring in the ENUM VALUESs
+  LEFT JOIN (
+    SELECT
+      "enumtypid",
+      "array_agg"("enumlabel")::varchar[] AS "enumValues"
+    FROM
+      "pg_catalog"."pg_enum"
+    GROUP BY
+      "enumtypid"
+  ) "e"
+  ON
+    "t"."oid" = "e"."enumtypid"
+  -- join the pg_catalog.pg_description to bring in the column DESCRIPTIONs
+  LEFT JOIN
+    "pg_catalog"."pg_description" AS "d"
+  ON
+    "d"."objoid" = "s"."relid" AND
+    "d"."objsubid" = "c"."ordinal_position"
+  -- restrict to our schemas
+  WHERE
+    "c"."table_schema" = ANY($1)
+  -- sanity in ordering
+  ORDER BY
+    "c"."table_schema",
+    "c"."table_name",
+    "c"."ordinal_position"`
+
+/** Interface describing the result from our query above */
+interface ResultRow {
+  schema: string,
+  table: string,
+  column: string,
+  isNullable: boolean,
+  hasDefault: boolean,
+  oid: number,
+  enumValues: string[] | null,
+  description: string | null,
+}
+
+/** Strip all undefined values from a record */
+function stripUndefined<T extends Record<string, any>>(object: T): T {
+  for (const key of Object.keys(object)) {
+    if (object[key] === undefined) delete object[key]
+  }
+  return object
+}
+
+/* ========================================================================== *
+ * EXPORTED                                                                   *
+ * ========================================================================== */
+
+/**
+ * Extract a {@link Schema} from an array of PosgreSQL schema names.
+ *
+ * When the `schemas` parameter is undefined (or an empty array), then the
+ * single `public` schema will be targeted for extraction.
+ *
+ * Furthermore, unless the `extractAll` flag is set to `true`, only tables and
+ * columns starting with a _latin letter_ (a...z) will be included in the
+ * resulting {@link Schema}.
+ *
+ * @param url - The URL of the database to connect to.
+ * @param schemas - The array of schema names to target for extraction.
+ * @param extractAll - Extract all tables and column definitions.
+ */
+export async function extractSchema(
+    url: URL | string,
+    schemas: string[] = [],
+    extractAll: boolean = false,
+): Promise<Schema> {
+  if (schemas.length === 0) schemas.push('public')
+
+  const client = new PGClient(url)
+  let rows: ResultRow[]
+  try {
+    const result = await client.query<ResultRow>(query, [ schemas ])
+    rows = result.rows
+  } finally {
+    await client.destroy()
+  }
+
+  const schemaDef: Schema = {}
+
+  for (const row of rows) {
+    const { schema, table, column, description, enumValues, ...def } = row
+
+    if (! extractAll) {
+      if ((table.match(/^[^a-z]/i)) || (column.match(/^[^a-z]/i))) continue
+    }
+
+    const name = schema === 'public' ? `${table}` : `${schema}.${table}`
+    const tableDef = schemaDef[name] || (schemaDef[name] = {})
+
+    tableDef[column] = stripUndefined({ ...def,
+      description: description?.trim() ? description.trim() : undefined,
+      enumValues: (enumValues && enumValues.length) ? enumValues as any : undefined,
+    })
+  }
+
+  return schemaDef
+}

package/src/helpers.ts

@@ -0,0 +1,30 @@
+import ts from 'typescript'
+
+/**
+ * Create a PosgreSQL array type for the given type, that is, given the type
+ * `T`, return `(T | null)[]`
+ */
+export function makePostgresArrayType(type: ts.TypeNode): ts.ArrayTypeNode {
+  const nullable = ts.factory.createLiteralTypeNode(ts.factory.createNull())
+  const union = ts.factory.createUnionTypeNode([ type, nullable ])
+  const array = ts.factory.createArrayTypeNode(union)
+  return array
+}
+
+/**
+ * Create an _import_ type, like `import('module').Name<arg0, arg1, ...>`.
+ */
+export function makeImportType(
+    module: string,
+    name: string,
+    args: ts.TypeNode | ts.TypeNode[] = [],
+): ts.ImportTypeNode {
+  if (! Array.isArray(args)) args = [ args ]
+
+  return ts.factory.createImportTypeNode( // ..................... "import"
+      ts.factory.createLiteralTypeNode(
+          ts.factory.createStringLiteral(module)), // ............ "('module')"
+      undefined, // import assertions
+      ts.factory.createIdentifier(name), // ........................ ".Type"
+      args) // ................................................... "<Arg, ...>"
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+/** Schema definition extracted from PostgreSQL */
+export interface Schema {
+  [ table: string ] : {
+    [ column: string ] : {
+      oid: number,
+      isNullable?: boolean,
+      hasDefault?: boolean,
+      description?: string,
+      enumValues?: readonly [ string, ...string[] ],
+    }
+  }
+}
+
+export * from './database'
+export * from './extract'
+export * from './migrate'
+export * from './serialize'
+
+/** Helper functions for serializing schemas */
+export * as helpers from './helpers'
+/** Known/basic types for serializing schemas */
+export * as types from './types'

package/src/migrate.ts

@@ -0,0 +1,177 @@
+import crypto from 'node:crypto'
+import { basename } from 'node:path'
+
+import { Persister } from '@juit/pgproxy-persister'
+import { $blu, $grn, $gry, $ms, $und, $ylw, find, fs, log, merge, resolve } from '@plugjs/plug'
+
+import type { InferSelectType } from '@juit/pgproxy-persister'
+
+/* ========================================================================== *
+ * INTERNALS                                                                  *
+ * ========================================================================== */
+
+const migrationsExpression = /^([0-9]+)[^\w](.*)\.(sql)$/i
+
+type Migration = {
+  sha256sum: Buffer,
+  contents: string,
+  number: number,
+  name: string,
+}
+
+interface MigrationSchema {
+  $migrations: {
+    group: { type: string, hasDefault: true },
+    number: { type: number },
+    name: { type: string },
+    timestamp: { type: Date, hasDefault: true },
+    sha256sum: { type: Buffer },
+  },
+}
+
+/* ========================================================================== *
+ * EXPORTS                                                                    *
+ * ========================================================================== */
+
+export type MigrationOptions = {
+  /** The directory where migrations SQL files reside (default: `./sql`) */
+  migrations?: string,
+  /**
+   * The directory (or directories) where _additional_ migrations SQL files
+   * reside (default: _undefined_).
+   */
+  additional?: string | string[],
+  /** The group identifier for this migrations (default: `default`) */
+  group?: string,
+}
+
+/** Migrate a database, applying all changes from a set of SQL files */
+export async function migrate(
+    url: string | URL,
+    options?: MigrationOptions,
+): Promise<number> {
+  const {
+    /* Default to our "../sql" migrations directory */
+    migrations: migrationsDirectory = resolve('sql'),
+    /* Our default group name is "default" */
+    group = 'default',
+    /* Optional additional directory for migrations */
+    additional,
+  } = { ...options }
+
+  /* Read our directory containing all our migrations files */
+  let entries = await find('*.sql', { directory: migrationsDirectory })
+
+  /* If we have additional paths configured, read those too */
+  if (additional) {
+    for (const addition of [ additional ].flat()) {
+      const additional = await find('*.sql', { directory: addition })
+      entries = await merge([ entries, additional ])
+    }
+  }
+
+  /* For each entry, map it to null or a migration entry */
+  const promises = [ ...entries.absolutePaths() ].map(async (file) => {
+    /* Match our file name, the groups identify our variables */
+    const match = migrationsExpression.exec(basename(file))
+    if (! match) return // no match, no migration
+
+    /* Extract file, number and name from match */
+    const [ , number, name ] = match
+
+    /* Read up our source file (additions have "source" in the dirent) */
+    const contents = await fs.readFile(file)
+
+    /* Return our migration entry */
+    return {
+      sha256sum: crypto.createHash('sha256').update(contents).digest(),
+      contents: contents.toString('utf8'),
+      number: parseInt(number!),
+      name: name!,
+    }
+  })
+
+  /* Filter unmatched migrations and sort them by migration _number_ */
+  const migrationFiles = (await Promise.all(promises))
+      .filter((migration): migration is Migration => !! migration)
+      .sort((a, b) => a!.number - b!.number)
+
+  /* Start our gigantic migrations transaction */
+  const now = Date.now()
+  const persister = new Persister<MigrationSchema>(url)
+  return await persister.connect(async (connection) => {
+    const info = await connection.query<{ name: string }>('SELECT current_database() AS name')
+    log.notice(`Migrating database ${$ylw((info.rows[0]!.name))}`)
+
+    const model = connection.in('$migrations')
+
+    log.info('Beginning migrations transaction')
+    await connection.begin()
+
+    /* First of all, make sure we have our "$migrations" table */
+    log.info(`Ensuring presence of ${$blu('$migrations')} table`)
+    await connection.query(`
+      SET LOCAL client_min_messages TO WARNING;
+      CREATE TABLE IF NOT EXISTS "$migrations" (
+        "group"     VARCHAR(32)  NOT NULL DEFAULT 'default',
+        "number"    INTEGER      NOT NULL,
+        "name"      TEXT         NOT NULL,
+        "timestamp" TIMESTAMPTZ  NOT NULL DEFAULT NOW(),
+        "sha256sum" BYTEA        NOT NULL,
+        PRIMARY KEY ("group", "number")
+      );`)
+
+    /* Lock our migrations table */
+    log.info(`Lock exclusive use of ${$blu('$migrations')} table`)
+    await connection.query('LOCK TABLE "$migrations"')
+
+    /* Gather all applied migrations */
+    log.info(`Looking for entries in ${$blu('$migrations')} table`)
+    const result = await model.read({ group })
+
+    /* Reduce all existing migration, keying them by number */
+    const applied = result.reduce((applied, row) => {
+      const { group, number, name, timestamp, sha256sum } = row
+      applied[number] = { group, number, name, timestamp, sha256sum }
+      return applied
+    }, {} as Record<number, InferSelectType<MigrationSchema['$migrations']>>)
+
+    /* Apply our migrations */
+    let count = 0
+    for (const { number, name, contents, sha256sum } of migrationFiles) {
+      const num = `${number}`.padStart(3, '0')
+      const prev = applied[number]
+      if (prev) {
+        if (sha256sum.equals(prev.sha256sum)) {
+          const timestamp = prev.timestamp.toISOString().substring(0, 19).replace('T', ' ')
+          log.notice(`Skipping migration ${$gry(`${group}@`)}${$grn(num)}: ${$blu(name)}`, $gry(`applied on ${$und(timestamp)}`))
+        } else {
+          log.error(`Failed migration ${$gry(`${group}@`)}${$grn(num)}: ${$ylw(name)}`)
+          const currHash = sha256sum.toString('hex').substring(0, 6)
+          const prevHash = Buffer.from(prev.sha256sum).toString('hex').substring(0, 6)
+          throw new Error(`Migration ${group}@${num} (${name}) has checksum "${currHash}" but was recorded as "${prevHash}"`)
+        }
+      } else {
+        try {
+          log.notice(`Applying migration ${$gry(`${group}@`)}${$grn(num)}: ${$blu(name)}`)
+          await connection.query(contents)
+          await model.create({ group, number, name, sha256sum })
+          count ++
+        } catch (error: any) {
+          log.error(`Failed migration ${$gry(`${group}@`)}${$grn(num)}: ${$ylw(name)}`)
+          const message = error.message.split('\n').map((s: string) => `  ${s}`).join('\n')
+          error.message = `Failed migration ${group}@${num} (${name}):\n${message}`
+          throw error
+        }
+      }
+    }
+
+    /* Commit our migrations */
+    log.info('Committing migrations transaction')
+    await connection.commit()
+
+    /* All done */
+    log.notice(`Applied ${$ylw(count)} migrations ${$ms(Date.now() - now)}`)
+    return count
+  }).finally(() => persister.destroy())
+}

package/src/serialize.ts

@@ -0,0 +1,217 @@
+import '@juit/pgproxy-client-psql'
+import { PGOIDs } from '@juit/pgproxy-types'
+import ts from 'typescript'
+
+import * as types from './types'
+
+import type { Schema } from './index'
+
+/* ========================================================================== *
+ * TYPES AND CONSTANTS                                                        *
+ * ========================================================================== */
+
+const exportModifier = ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+const endOfFileToken = ts.factory.createToken(ts.SyntaxKind.EndOfFileToken)
+
+const oidTypes = {
+  /* Basic known types                                |_oid__|_typname______| */
+  [PGOIDs.bool]: types.booleanType, /*                |   16 | bool         | */
+  [PGOIDs.bytea]: types.uint8ArrayType, /*            |   17 | bytea        | */
+  [PGOIDs.int8]: types.bigintType, /*                 |   20 | int8         | */
+  [PGOIDs.int2]: types.numberType, /*                 |   21 | int2         | */
+  [PGOIDs.int4]: types.numberType, /*                 |   23 | int4         | */
+  [PGOIDs.oid]: types.numberType, /*                  |   26 | oid          | */
+  [PGOIDs.json]: types.anyType, /*                    |  114 | json         | */
+  [PGOIDs.point]: types.pgPointType, /*               |  600 | point        | */
+  [PGOIDs.float4]: types.numberType, /*               |  700 | float4       | */
+  [PGOIDs.float8]: types.numberType, /*               |  701 | float8       | */
+  [PGOIDs.circle]: types.pgCircleType, /*             |  718 | circle       | */
+  [PGOIDs.varchar]: types.stringType, /*              | 1043 | varchar      | */
+  [PGOIDs.timestamp]: types.dateType, /*              | 1114 | timestamp    | */
+  [PGOIDs.timestamptz]: types.dateType, /*            | 1184 | timestamptz  | */
+  [PGOIDs.interval]: types.pgIntervalType, /*         | 1186 | interval     | */
+  [PGOIDs.numeric]: types.stringType, /*              | 1700 | numeric      | */
+  [PGOIDs.jsonb]: types.anyType, /*                   | 3802 | jsonb        | */
+
+  /* Special types                                    |_oid__|_typname______| */
+  [PGOIDs.void]: types.voidType, /*                   | 2278 | void         | */
+  [PGOIDs.xid]: types.numberType, /*                  |   28 | xid          | */
+  [PGOIDs.xid8]: types.bigintType, /*                 | 5069 | xid8         | */
+  [PGOIDs._xid]: types.numberArrayType, /*            | 1011 | _xid         | */
+  [PGOIDs._xid8]: types.bigintArrayType, /*           |  271 | _xid8        | */
+
+  /* Native array types of the above                  |_oid__|_typname______| */
+  [PGOIDs._bool]: types.booleanArrayType, /*          | 1000 | _bool        | */
+  [PGOIDs._bytea]: types.uint8ArrayArrayType, /*      | 1001 | _bytea       | */
+  [PGOIDs._int8]: types.bigintArrayType, /*           | 1016 | _int8        | */
+  [PGOIDs._int2]: types.numberArrayType, /*           | 1005 | _int2        | */
+  [PGOIDs._int4]: types.numberArrayType, /*           | 1007 | _int4        | */
+  [PGOIDs._oid]: types.numberArrayType, /*            | 1028 | _oid         | */
+  [PGOIDs._json]: types.anyArrayType, /*              |  199 | _json        | */
+  [PGOIDs._point]: types.pgPointArrayType, /*         | 1017 | _point       | */
+  [PGOIDs._float4]: types.numberArrayType, /*         | 1021 | _float4      | */
+  [PGOIDs._float8]: types.numberArrayType, /*         | 1022 | _float8      | */
+  [PGOIDs._circle]: types.pgCircleArrayType, /*       |  719 | _circle      | */
+  [PGOIDs._timestamp]: types.dateArrayType, /*        | 1115 | _timestamp   | */
+  [PGOIDs._timestamptz]: types.dateArrayType, /*      | 1185 | _timestamptz | */
+  [PGOIDs._interval]: types.pgIntervalArrayType, /*   | 1187 | _interval    | */
+  [PGOIDs._numeric]: types.stringArrayType, /*        | 1231 | _numeric     | */
+  [PGOIDs._jsonb]: types.anyArrayType, /*             | 3807 | _jsonb       | */
+
+  /* Other known array types                          |_oid__|_typname______| */
+  [PGOIDs._cidr]: types.stringArrayType, /*           |  651 | _cidr        | */
+  [PGOIDs._money]: types.stringArrayType, /*          |  791 | _money       | */
+  [PGOIDs._regproc]: types.stringArrayType, /*        | 1008 | _regproc     | */
+  [PGOIDs._text]: types.stringArrayType, /*           | 1009 | _text        | */
+  [PGOIDs._bpchar]: types.stringArrayType, /*         | 1014 | _bpchar      | */
+  [PGOIDs._varchar]: types.stringArrayType, /*        | 1015 | _varchar     | */
+  [PGOIDs._macaddr]: types.stringArrayType, /*        | 1040 | _macaddr     | */
+  [PGOIDs._inet]: types.stringArrayType, /*           | 1041 | _inet        | */
+  [PGOIDs._date]: types.stringArrayType, /*           | 1182 | _date        | */
+  [PGOIDs._time]: types.stringArrayType, /*           | 1183 | _time        | */
+  [PGOIDs._timetz]: types.stringArrayType, /*         | 1270 | _timetz      | */
+  [PGOIDs._uuid]: types.stringArrayType, /*           | 2951 | _uuid        | */
+
+  /* Range types                                      |_oid__|_typname______| */
+  [PGOIDs.int4range]: types.numberRangeType, /*       | 3904 | int4range    | */
+  [PGOIDs.numrange]: types.numberRangeType, /*        | 3906 | numrange     | */
+  [PGOIDs.tsrange]: types.dateRangeType, /*           | 3908 | tsrange      | */
+  [PGOIDs.tstzrange]: types.dateRangeType, /*         | 3910 | tstzrange    | */
+  [PGOIDs.daterange]: types.stringRangeType, /*       | 3912 | daterange    | */
+  [PGOIDs.int8range]: types.bigintRangeType, /*       | 3926 | int8range    | */
+
+  /* Array of range types                             |_oid__|_typname______| */
+  [PGOIDs._int4range]: types.numberRangeArrayType, /* | 3905 | _int4range   | */
+  [PGOIDs._numrange]: types.numberRangeArrayType, /*  | 3907 | _numrange    | */
+  [PGOIDs._tsrange]: types.dateRangeArrayType, /*     | 3909 | _tsrange     | */
+  [PGOIDs._tstzrange]: types.dateRangeArrayType, /*   | 3911 | _tstzrange   | */
+  [PGOIDs._daterange]: types.stringRangeArrayType, /* | 3913 | _daterange   | */
+  [PGOIDs._int8range]: types.bigintRangeArrayType, /* | 3927 | _int8range   | */
+} satisfies Record<PGOIDs[keyof PGOIDs], ts.TypeNode>
+
+const trueLiteralTypeNode = ts.factory.createLiteralTypeNode(
+    ts.factory.createToken(ts.SyntaxKind.TrueKeyword))
+
+const isNullableSignature = ts.factory.createPropertySignature(
+    undefined, // no modifiers
+    'isNullable',
+    undefined, // no question mark
+    trueLiteralTypeNode)
+
+const hasDefaultSignature = ts.factory.createPropertySignature(
+    undefined, // no modifiers
+    'hasDefault',
+    undefined, // no question mark
+    trueLiteralTypeNode)
+
+/* ========================================================================== *
+ * EXPORTED                                                                   *
+ * ========================================================================== */
+
+/**
+ * Serialize the specified `Schema` as a TypeScript source file.
+ *
+ * If the `id` is unspecified, the default name `Schema` will be used.
+ */
+export function serializeSchema(
+    schema: Schema,
+    id: string = 'Schema',
+    overrides: Record<number, ts.TypeNode> = {},
+): string {
+/* Property signatures of all tables */
+  const tables: ts.PropertySignature[] = []
+
+  /* Iterate through our tables */
+  for (const [ tableName, table ] of Object.entries(schema)) {
+  /* Property signatures of all columns in the current table */
+    const columns: ts.PropertySignature[] = []
+
+    /* Iterate through our table's columns */
+    for (const [ columnName, column ] of Object.entries(table)) {
+      let typeNode: ts.TypeNode
+
+      /* First look at any type overridden when calling this */
+      if (column.oid in overrides) {
+        typeNode = overrides[column.oid]!
+
+        /* Then look at our well-known types */
+      } else if (column.oid in oidTypes) {
+        typeNode = oidTypes[column.oid as keyof typeof oidTypes]
+
+        /* Still nothing? Maybe it's an enum (a union type) */
+      } else if (column.enumValues) {
+        typeNode = ts.factory.createUnionTypeNode(
+            column.enumValues.map((value) =>
+              ts.factory.createLiteralTypeNode(
+                  ts.factory.createStringLiteral(value),
+              )))
+
+        /* Anything else is a string... */
+      } else {
+        typeNode = types.stringType
+      }
+
+      /* Create the _type_ signature for this column */
+      const typeSignature = ts.factory.createPropertySignature(
+          undefined, // no modifiers
+          'type',
+          undefined, // no question mark
+          typeNode,
+      )
+
+      /* Create the property signature for this column */
+      const definition: ts.PropertySignature[] = [ typeSignature ]
+      if (column.hasDefault) definition.push(hasDefaultSignature)
+      if (column.isNullable) definition.push(isNullableSignature)
+
+      const columnSignature = ts.factory.createPropertySignature(
+          undefined, // no modifiers
+          ts.factory.createStringLiteral(columnName),
+          undefined, // no question mark
+          ts.factory.createTypeLiteralNode(definition),
+      )
+
+      /* If we have a description, add it as a JSDoc comment */
+      if (column.description) {
+        ts.addSyntheticLeadingComment(
+            columnSignature,
+            ts.SyntaxKind.MultiLineCommentTrivia,
+            `* ${column.description} `,
+            true, // trailing newline!
+        )
+      }
+
+      /* All done with this column, push its signature */
+      columns.push(columnSignature)
+    }
+
+    /* Create the table signature from all the columns */
+    const tableSignature = ts.factory.createPropertySignature(
+        undefined, // modifiers
+        ts.factory.createStringLiteral(tableName),
+        undefined, // question mark
+        ts.factory.createTypeLiteralNode(columns), // as any,
+    )
+    tables.push(tableSignature)
+  }
+
+  /* Create our schema declaration, as an exported interface */
+  const declaration = ts.factory.createInterfaceDeclaration(
+      [ exportModifier ], // export modifier
+      id, // the name of the schema, "Schema" or whatever we were given
+      undefined, // no type parameters
+      undefined, // no heritage clause
+      tables, // all our tables signatures
+  )
+
+  /* Wrap our source interface declaration in a source file */
+  const source = ts.factory.createSourceFile(
+      [ declaration ],
+      endOfFileToken,
+      ts.NodeFlags.None,
+  )
+
+  /* Create a printer, and stringify our source file */
+  const content = ts.createPrinter().printFile(source)
+  return content
+}

package/src/types.ts

@@ -0,0 +1,51 @@
+import ts from 'typescript'
+
+import { makeImportType, makePostgresArrayType } from './helpers'
+
+/* Null and void */
+export const nullType = ts.factory.createLiteralTypeNode(ts.factory.createNull())
+export const voidType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)
+
+/* Basic types and primitives */
+export const anyType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+export const bigintType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword)
+export const booleanType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)
+export const numberType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+export const stringType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+
+/* Objects */
+export const dateType = ts.factory.createTypeReferenceNode('Date')
+export const uint8ArrayType = ts.factory.createTypeReferenceNode('Uint8Array')
+
+/* Basic arrays */
+export const anyArrayType = makePostgresArrayType(anyType)
+export const bigintArrayType = makePostgresArrayType(bigintType)
+export const booleanArrayType = makePostgresArrayType(booleanType)
+export const numberArrayType = makePostgresArrayType(numberType)
+export const stringArrayType = makePostgresArrayType(stringType)
+
+/* Object arrays */
+export const dateArrayType = makePostgresArrayType(dateType)
+export const uint8ArrayArrayType = makePostgresArrayType(uint8ArrayType)
+
+/* Imported */
+export const pgCircleType: ts.TypeNode = makeImportType('@juit/pgproxy-types', 'PGCircle')
+export const pgIntervalType: ts.TypeNode = makeImportType('@juit/pgproxy-types', 'PGInterval')
+export const pgPointType: ts.TypeNode = makeImportType('@juit/pgproxy-types', 'PGPoint')
+
+/* Imported arrays */
+export const pgCircleArrayType = makePostgresArrayType(pgCircleType)
+export const pgIntervalArrayType = makePostgresArrayType(pgIntervalType)
+export const pgPointArrayType = makePostgresArrayType(pgPointType)
+
+/* Ranges */
+export const bigintRangeType = makeImportType('@juit/pgproxy-types', 'PGRange', bigintType)
+export const numberRangeType = makeImportType('@juit/pgproxy-types', 'PGRange', numberType)
+export const stringRangeType = makeImportType('@juit/pgproxy-types', 'PGRange', stringType)
+export const dateRangeType = makeImportType('@juit/pgproxy-types', 'PGRange', dateType)
+
+/* Range arrays */
+export const bigintRangeArrayType = makePostgresArrayType(bigintRangeType)
+export const numberRangeArrayType = makePostgresArrayType(numberRangeType)
+export const stringRangeArrayType = makePostgresArrayType(stringRangeType)
+export const dateRangeArrayType = makePostgresArrayType(dateRangeType)