drizzle-fp 0.1.0

package/src/columnsWithExtraTableConfigsAdders/addColumnWithFk.ts

@@ -0,0 +1,27 @@
+import type { PgColumnBuilderBase } from 'drizzle-orm/pg-core'
+
+import { flow } from 'effect/Function'
+
+import {
+  addColumn,
+  type FunctionExtendingColumnsMap,
+} from '../columnsAdders/index.ts'
+import {
+  addFk,
+  type ForeignTableColumnGetter,
+} from '../extraTableConfigsAdders/index.ts'
+
+export const addColumnWithFk = <
+  const NameOfColumnInCurrentTable extends string,
+  ColumnBuilder extends PgColumnBuilderBase,
+>(
+  nameOfColumnInCurrentTable: NameOfColumnInCurrentTable,
+  buildColumn: () => ColumnBuilder,
+  getColumnOfForeignTable: ForeignTableColumnGetter,
+): FunctionExtendingColumnsMap<{
+  [Key in NameOfColumnInCurrentTable]: ColumnBuilder
+}> =>
+  flow(
+    addColumn(nameOfColumnInCurrentTable, buildColumn),
+    addFk(nameOfColumnInCurrentTable, getColumnOfForeignTable),
+  ) as any

package/src/columnsWithExtraTableConfigsAdders/addColumnsOfTheSameTypeWithCompositeFk.ts

@@ -0,0 +1,36 @@
+import type { AnyPgTable, PgColumnBuilderBase } from 'drizzle-orm/pg-core'
+
+import type {
+  AllowOnlyNonEmptyObjectsWithActualKeys,
+  FunctionExtendingColumnsMap,
+} from '../columnsAdders/index.ts'
+import { addColumnsWithCompositeFk } from './addColumnsWithCompositeFk.ts'
+
+export const addColumnsOfTheSameTypeWithCompositeFk = <
+  const FkConfig extends [FkConfig] extends [infer U]
+    ? AllowOnlyNonEmptyObjectsWithActualKeys<U, keyof NoInfer<TTable>>
+    : never,
+  TTable extends AnyPgTable,
+  ColumnBuilder extends PgColumnBuilderBase,
+>(
+  getForeignTable: () => TTable,
+  buildColumn: () => ColumnBuilder,
+  fkConfig: FkConfig,
+): FunctionExtendingColumnsMap<
+  Record<keyof NoInfer<FkConfig>, ColumnBuilder>
+> =>
+  addColumnsWithCompositeFk(
+    getForeignTable,
+    () =>
+      Object.fromEntries(
+        Object.entries(
+          fkConfig as unknown as Record<string, keyof NoInfer<TTable>>,
+        ).map(([ownColumnName, foreignColumnName]) => [
+          ownColumnName,
+          {
+            currentColumnBuilder: buildColumn(),
+            foreignColumnName,
+          },
+        ]),
+      ) as any,
+  )

package/src/columnsWithExtraTableConfigsAdders/addColumnsOfTheSameTypeWithCompositeFk1to1.ts

@@ -0,0 +1,23 @@
+import type { AnyPgTable, PgColumnBuilderBase } from 'drizzle-orm/pg-core'
+
+import type { FunctionExtendingColumnsMap } from '../columnsAdders/index.ts'
+import { addColumnsOfTheSameTypeWithCompositeFk } from './addColumnsOfTheSameTypeWithCompositeFk.ts'
+
+export const addColumnsOfTheSameTypeWithCompositeFk1to1 = <
+  const FkConfig extends readonly [
+    keyof TTable,
+    keyof TTable,
+    ...(keyof TTable)[],
+  ],
+  TTable extends AnyPgTable,
+  ColumnBuilder extends PgColumnBuilderBase,
+>(
+  getForeignTable: () => TTable,
+  buildColumn: () => ColumnBuilder,
+  fkConfig: FkConfig,
+): FunctionExtendingColumnsMap<Record<FkConfig[number], ColumnBuilder>> =>
+  addColumnsOfTheSameTypeWithCompositeFk(
+    getForeignTable,
+    buildColumn,
+    Object.fromEntries(fkConfig.map(column => [column, column])) as any,
+  )

package/src/columnsWithExtraTableConfigsAdders/addColumnsWithCompositeFk.ts

@@ -0,0 +1,60 @@
+import type { AnyPgTable, PgColumnBuilderBase } from 'drizzle-orm/pg-core'
+
+import { flow } from 'effect/Function'
+
+import {
+  type AllowOnlyNonEmptyObjectsWithActualKeys,
+  addColumns,
+  type FunctionExtendingColumnsMap,
+} from '../columnsAdders/index.ts'
+import { addCompositeFk } from '../extraTableConfigsAdders/addCompositeFk.ts'
+
+export const addColumnsWithCompositeFk = <
+  const FkConfig extends [FkConfig] extends [infer U]
+    ? AllowOnlyNonEmptyObjectsWithActualKeys<
+        U,
+        BatchColumnAdderValueOfRecord<TTable>
+      >
+    : never,
+  TTable extends AnyPgTable,
+>(
+  getForeignTable: () => TTable,
+  fkConfig: () => FkConfig,
+): FunctionExtendingColumnsMap<{
+  [ColumnName in keyof FkConfig]: FkConfig[ColumnName] extends {
+    currentColumnBuilder: infer U
+  }
+    ? U
+    : never
+}> => {
+  type Entry = [string, BatchColumnAdderValueOfRecord<TTable>]
+
+  const compositeFkConfig = Object.fromEntries(
+    (Object.entries(fkConfig()) as unknown as Entry[]).map(
+      ([ownColumnName, { foreignColumnName }]) => [
+        ownColumnName,
+        foreignColumnName,
+      ],
+    ),
+  )
+
+  return flow(
+    addColumns(
+      () =>
+        Object.fromEntries(
+          (Object.entries(fkConfig()) as unknown as Entry[]).map(
+            ([ownColumnName, { currentColumnBuilder }]) => [
+              ownColumnName,
+              currentColumnBuilder,
+            ],
+          ),
+        ) as any,
+    ),
+    addCompositeFk(getForeignTable, compositeFkConfig),
+  ) as any
+}
+
+type BatchColumnAdderValueOfRecord<TTable> = {
+  currentColumnBuilder: PgColumnBuilderBase
+  foreignColumnName: keyof NoInfer<TTable>
+}

package/src/columnsWithExtraTableConfigsAdders/addIntegerIdColumnAsPrimaryKey.ts

@@ -0,0 +1,27 @@
+import type { IsIdentity, NotNull } from 'drizzle-orm'
+import { integer, type PgIntegerBuilderInitial } from 'drizzle-orm/pg-core'
+
+import { pipe } from 'effect/Function'
+
+import { addColumns, type GeneralColumnMap } from '../columnsAdders/index.ts'
+import { addPrimaryKey } from '../extraTableConfigsAdders/index.ts'
+import type { TableFuncArgs } from '../TableFuncArgs.ts'
+
+export const addIntegerIdColumnAsPrimaryKey = <
+  const TTableName extends string,
+  TColumnsMap extends GeneralColumnMap,
+>(
+  args: TableFuncArgs<TTableName, TColumnsMap>,
+): TableFuncArgs<
+  TTableName,
+  TColumnsMap & { id: PgIntegerGeneratedAlwaysAsIdentity<TTableName> }
+> =>
+  pipe(
+    addColumns(() => ({
+      id: integer(`${args[0]}_id`).generatedAlwaysAsIdentity(),
+    }))(args),
+    addPrimaryKey('id'),
+  )
+
+export type PgIntegerGeneratedAlwaysAsIdentity<TTableName extends string> =
+  IsIdentity<NotNull<PgIntegerBuilderInitial<`${TTableName}_id`>>, 'always'>

package/src/columnsWithExtraTableConfigsAdders/addIntegerRequiredColumnWithFk.ts

@@ -0,0 +1,21 @@
+import {
+  type FunctionExtendingColumnsMap,
+  type NonNullInteger,
+  nonNullInteger,
+} from '../columnsAdders/index.ts'
+import type { ForeignTableColumnGetter } from '../extraTableConfigsAdders/index.ts'
+import { addColumnWithFk } from './addColumnWithFk.ts'
+
+export const addIntegerRequiredColumnWithFk = <
+  const NameOfColumnInCurrentTable extends string,
+>(
+  nameOfColumnInCurrentTable: NameOfColumnInCurrentTable,
+  getColumnOfForeignTable: ForeignTableColumnGetter,
+): FunctionExtendingColumnsMap<
+  Record<NameOfColumnInCurrentTable, NonNullInteger>
+> =>
+  addColumnWithFk(
+    nameOfColumnInCurrentTable,
+    nonNullInteger,
+    getColumnOfForeignTable,
+  )

package/src/columnsWithExtraTableConfigsAdders/addIntegerRequiredColumnsWithCompositeFk.ts

@@ -0,0 +1,26 @@
+import type { AnyPgTable } from 'drizzle-orm/pg-core'
+
+import {
+  type AllowOnlyNonEmptyObjectsWithActualKeys,
+  type FunctionExtendingColumnsMap,
+  type NonNullInteger,
+  nonNullInteger,
+} from '../columnsAdders/index.ts'
+import { addColumnsOfTheSameTypeWithCompositeFk } from './addColumnsOfTheSameTypeWithCompositeFk.ts'
+
+export const addIntegerRequiredColumnsWithCompositeFk = <
+  const FkConfig extends [FkConfig] extends [infer U]
+    ? AllowOnlyNonEmptyObjectsWithActualKeys<U, keyof NoInfer<TTable>>
+    : never,
+  TTable extends AnyPgTable,
+>(
+  getForeignTable: () => TTable,
+  fkConfig: FkConfig,
+): FunctionExtendingColumnsMap<
+  Record<keyof NoInfer<FkConfig>, NonNullInteger>
+> =>
+  addColumnsOfTheSameTypeWithCompositeFk(
+    getForeignTable,
+    nonNullInteger,
+    fkConfig,
+  )

package/src/columnsWithExtraTableConfigsAdders/addIntegerRequiredColumnsWithCompositeFk1to1.ts

@@ -0,0 +1,25 @@
+import type { AnyPgTable } from 'drizzle-orm/pg-core'
+
+import {
+  type FunctionExtendingColumnsMap,
+  type NonNullInteger,
+  nonNullInteger,
+} from '../columnsAdders/index.ts'
+import { addColumnsOfTheSameTypeWithCompositeFk1to1 } from './addColumnsOfTheSameTypeWithCompositeFk1to1.ts'
+
+export const addIntegerRequiredColumnsWithCompositeFk1to1 = <
+  const FkConfig extends readonly [
+    keyof TTable,
+    keyof TTable,
+    ...(keyof TTable)[],
+  ],
+  TTable extends AnyPgTable,
+>(
+  getForeignTable: () => TTable,
+  fkConfig: FkConfig,
+): FunctionExtendingColumnsMap<Record<FkConfig[number], NonNullInteger>> =>
+  addColumnsOfTheSameTypeWithCompositeFk1to1(
+    getForeignTable,
+    nonNullInteger,
+    fkConfig,
+  )

package/src/columnsWithExtraTableConfigsAdders/addTextRequiredColumnWithFk.ts

@@ -0,0 +1,21 @@
+import {
+  type FunctionExtendingColumnsMap,
+  type NonNullText,
+  nonNullText,
+} from '../columnsAdders/index.ts'
+import type { ForeignTableColumnGetter } from '../extraTableConfigsAdders/index.ts'
+import { addColumnWithFk } from './addColumnWithFk.ts'
+
+export const addTextRequiredColumnWithFk = <
+  const NameOfColumnInCurrentTable extends string,
+>(
+  nameOfColumnInCurrentTable: NameOfColumnInCurrentTable,
+  getColumnOfForeignTable: ForeignTableColumnGetter,
+): FunctionExtendingColumnsMap<
+  Record<NameOfColumnInCurrentTable, NonNullText>
+> =>
+  addColumnWithFk(
+    nameOfColumnInCurrentTable,
+    nonNullText,
+    getColumnOfForeignTable,
+  )

package/src/columnsWithExtraTableConfigsAdders/addUuidColumnAsPrimaryKey.ts

@@ -0,0 +1,25 @@
+import type { NotNull } from 'drizzle-orm'
+import { type PgUUIDBuilderInitial, uuid } from 'drizzle-orm/pg-core'
+
+import { pipe } from 'effect/Function'
+
+import { addColumns, type GeneralColumnMap } from '../columnsAdders/index.ts'
+import { addPrimaryKey } from '../extraTableConfigsAdders/index.ts'
+import type { TableFuncArgs } from '../TableFuncArgs.ts'
+
+export const addUuidColumnAsPrimaryKey = <
+  const TTableName extends string,
+  TColumnsMap extends GeneralColumnMap,
+>(
+  args: TableFuncArgs<TTableName, TColumnsMap>,
+): TableFuncArgs<TTableName, TColumnsMap & { id: PgUUID<TTableName> }> =>
+  pipe(
+    addColumns(() => ({
+      id: uuid(`${args[0]}_uuid`).notNull(),
+    }))(args),
+    addPrimaryKey('id'),
+  )
+
+export type PgUUID<TTableName extends string> = NotNull<
+  PgUUIDBuilderInitial<`${TTableName}_uuid`>
+>

package/src/columnsWithExtraTableConfigsAdders/addUuidRequiredColumnWithFk.ts

@@ -0,0 +1,21 @@
+import {
+  type FunctionExtendingColumnsMap,
+  type NonNullUUID,
+  nonNullUuid,
+} from '../columnsAdders/index.ts'
+import type { ForeignTableColumnGetter } from '../extraTableConfigsAdders/index.ts'
+import { addColumnWithFk } from './addColumnWithFk.ts'
+
+export const addUuidRequiredColumnWithFk = <
+  const NameOfColumnInCurrentTable extends string,
+>(
+  nameOfColumnInCurrentTable: NameOfColumnInCurrentTable,
+  getColumnOfForeignTable: ForeignTableColumnGetter,
+): FunctionExtendingColumnsMap<
+  Record<NameOfColumnInCurrentTable, NonNullUUID>
+> =>
+  addColumnWithFk(
+    nameOfColumnInCurrentTable,
+    nonNullUuid,
+    getColumnOfForeignTable,
+  )

package/src/columnsWithExtraTableConfigsAdders/index.ts

@@ -0,0 +1,16 @@
+export * from './addAutoGeneratedGloballyUniqueOrderingColumn.ts'
+export * from './addBigint53IdColumnAsPrimaryKey.ts'
+export * from './addBigint53RequiredColumnsWithCompositeFk.ts'
+export * from './addBigint53RequiredColumnsWithCompositeFk1to1.ts'
+export * from './addBigint53RequiredColumnWithFk.ts'
+export * from './addColumnsOfTheSameTypeWithCompositeFk.ts'
+export * from './addColumnsOfTheSameTypeWithCompositeFk1to1.ts'
+export * from './addColumnsWithCompositeFk.ts'
+export * from './addColumnWithFk.ts'
+export * from './addIntegerIdColumnAsPrimaryKey.ts'
+export * from './addIntegerRequiredColumnsWithCompositeFk.ts'
+export * from './addIntegerRequiredColumnsWithCompositeFk1to1.ts'
+export * from './addIntegerRequiredColumnWithFk.ts'
+export * from './addTextRequiredColumnWithFk.ts'
+export * from './addUuidColumnAsPrimaryKey.ts'
+export * from './addUuidRequiredColumnWithFk.ts'

package/src/extraTableConfigsAdders/ForeignTableColumnGetter.ts

@@ -0,0 +1,3 @@
+import type { AnyPgColumn } from 'drizzle-orm/pg-core'
+
+export type ForeignTableColumnGetter = () => AnyPgColumn<{ tableName: string }>

package/src/extraTableConfigsAdders/FunctionRequiringColumnsMap.ts

@@ -0,0 +1,13 @@
+import type { ColumnMap } from '../columnsAdders/index.ts'
+import type { TableFuncArgs } from '../TableFuncArgs.ts'
+
+export type FunctionRequiringColumnsMap<
+  TRequiredPresenceOfColumnNames extends string,
+> = <
+  const TTableName extends string,
+  TColumnsMap extends ColumnMap<TRequiredPresenceOfColumnNames> &
+    ColumnMap<string>,
+>([snakeCaseTableName, options, extraConfig]: TableFuncArgs<
+  TTableName,
+  TColumnsMap
+>) => TableFuncArgs<TTableName, TColumnsMap>

package/src/extraTableConfigsAdders/addCompositeFk.ts

@@ -0,0 +1,47 @@
+import { strSnakeCase } from '@nevware21/ts-utils'
+import type { AnyPgTable } from 'drizzle-orm/pg-core'
+import { foreignKey } from 'drizzle-orm/pg-core'
+
+import { addExtraConfig } from './addExtraConfig.ts'
+import type { FunctionRequiringColumnsMap } from './FunctionRequiringColumnsMap.ts'
+import { getCompressedIdentifierName } from './getCompressedIdentifierName.ts'
+
+export const addCompositeFk =
+  <
+    const TRequiredPresenceOfColumnNames extends string,
+    TTable extends AnyPgTable,
+  >(
+    getForeignTable: () => TTable,
+    fkConfig: Record<TRequiredPresenceOfColumnNames, keyof NoInfer<TTable>>,
+  ): FunctionRequiringColumnsMap<TRequiredPresenceOfColumnNames> =>
+  args =>
+    addExtraConfig(table => {
+      const currentTableName = args[0]
+      const ownColumnNamesInitial = Object.keys(fkConfig)
+      const ownColumnNamesSnakeCasedCloseToSQL = ownColumnNamesInitial.map(
+        name => strSnakeCase(table[name]?.name || name),
+      )
+
+      const foreignTable = getForeignTable() as any
+      const foreignTableName = foreignTable[Symbol.for('drizzle:Name')]
+
+      const foreignColumnNames = Object.values(fkConfig) as [any]
+      const foreignColumnNamesSnakeCasedCloseToSQL = foreignColumnNames.map(
+        name => strSnakeCase(foreignTable[name].name || name),
+      )
+
+      return [
+        foreignKey({
+          name: getCompressedIdentifierName('FK', [
+            currentTableName,
+            ...ownColumnNamesSnakeCasedCloseToSQL,
+            foreignTableName,
+            ...foreignColumnNamesSnakeCasedCloseToSQL,
+          ]),
+          columns: ownColumnNamesInitial.map(name => table[name]) as [any],
+          foreignColumns: foreignColumnNames.map(
+            name => foreignTable[name],
+          ) as [any],
+        }),
+      ]
+    })(args)

package/src/extraTableConfigsAdders/addCompositePrimaryKey.ts

@@ -0,0 +1,9 @@
+import { addPrimaryKey } from './addPrimaryKey.ts'
+import type { FunctionRequiringColumnsMap } from './FunctionRequiringColumnsMap.ts'
+
+export const addCompositePrimaryKey = <
+  const TColumnNames extends [string, string, ...string[]],
+>(
+  ...columnNames: TColumnNames
+): FunctionRequiringColumnsMap<TColumnNames[number]> =>
+  addPrimaryKey(...columnNames)

package/src/extraTableConfigsAdders/addExtraConfig.ts

@@ -0,0 +1,21 @@
+import type { PgTableExtraConfigValue } from 'drizzle-orm/pg-core'
+
+import type { ColumnMap, GeneralColumnMap } from '../columnsAdders/index.ts'
+import type { RemapToTableArgumentOfExtraConfigRenderer } from '../TableFuncArgs.ts'
+import type { FunctionRequiringColumnsMap } from './FunctionRequiringColumnsMap.ts'
+
+export const addExtraConfig =
+  <TRequiredPresenceOfColumnNames extends string = never>(
+    additionalExtraConfig: <
+      TColumnsMap extends GeneralColumnMap = GeneralColumnMap,
+    >(
+      table: RemapToTableArgumentOfExtraConfigRenderer<
+        TColumnsMap & ColumnMap<NoInfer<TRequiredPresenceOfColumnNames>>
+      >,
+    ) => PgTableExtraConfigValue[],
+  ): FunctionRequiringColumnsMap<TRequiredPresenceOfColumnNames> =>
+  ([snakeCaseTableName, options, extraConfig]) => [
+    snakeCaseTableName,
+    options,
+    table => [...extraConfig(table), ...additionalExtraConfig(table)],
+  ]

package/src/extraTableConfigsAdders/addFk.ts

@@ -0,0 +1,51 @@
+import { strSnakeCase } from '@nevware21/ts-utils'
+import { foreignKey } from 'drizzle-orm/pg-core'
+
+import { addExtraConfig } from './addExtraConfig.ts'
+import type { ForeignTableColumnGetter } from './ForeignTableColumnGetter.ts'
+import type { FunctionRequiringColumnsMap } from './FunctionRequiringColumnsMap.ts'
+import { getCompressedIdentifierName } from './getCompressedIdentifierName.ts'
+
+export const addFk =
+  <const NameOfColumnInCurrentTable extends string>(
+    ownInitialColumnName: NameOfColumnInCurrentTable,
+    getColumnOfForeignTable: ForeignTableColumnGetter,
+  ): FunctionRequiringColumnsMap<NameOfColumnInCurrentTable> =>
+  args =>
+    addExtraConfig(table => {
+      const currentTableName = args[0]
+      const ownColumnNameSnakeCasedCloseToSQL = strSnakeCase(
+        table[ownInitialColumnName].name || ownInitialColumnName,
+      )
+
+      const foreignColumn = getColumnOfForeignTable()
+      const foreignTableName = (foreignColumn.table as any)[
+        Symbol.for('drizzle:Name')
+      ] as string
+      const foreignColumnNamesSnakeCasedCloseToSQL = foreignColumn.name
+
+      const isForeignColumnNameAPrimitiveId =
+        `${foreignTableName}_id` === foreignColumnNamesSnakeCasedCloseToSQL
+
+      const doOwnAndForeignColumnNamesMatch =
+        ownColumnNameSnakeCasedCloseToSQL ===
+        foreignColumnNamesSnakeCasedCloseToSQL
+
+      return [
+        foreignKey({
+          name: getCompressedIdentifierName('FK', [
+            currentTableName,
+            ownColumnNameSnakeCasedCloseToSQL,
+            ...(isForeignColumnNameAPrimitiveId &&
+            doOwnAndForeignColumnNamesMatch
+              ? []
+              : isForeignColumnNameAPrimitiveId ||
+                  doOwnAndForeignColumnNamesMatch
+                ? [foreignTableName]
+                : [foreignTableName, foreignColumnNamesSnakeCasedCloseToSQL]),
+          ]),
+          columns: [table[ownInitialColumnName]],
+          foreignColumns: [foreignColumn],
+        }),
+      ]
+    })(args)

package/src/extraTableConfigsAdders/addPrimaryKey.ts

@@ -0,0 +1,17 @@
+import { primaryKey } from 'drizzle-orm/pg-core'
+
+import { addExtraConfig } from './addExtraConfig.ts'
+import type { FunctionRequiringColumnsMap } from './FunctionRequiringColumnsMap.ts'
+import { getCompressedIdentifierName } from './getCompressedIdentifierName.ts'
+
+export const addPrimaryKey =
+  <const TColumnNames extends [string, ...string[]]>(
+    ...columnNames: TColumnNames
+  ): FunctionRequiringColumnsMap<TColumnNames[number]> =>
+  args =>
+    addExtraConfig(table => [
+      primaryKey({
+        name: getCompressedIdentifierName('PK', [args[0]]),
+        columns: columnNames.map(name => table[name]) as any,
+      }),
+    ])(args)

package/src/extraTableConfigsAdders/addUniqueConstraintWithIndex.ts

@@ -0,0 +1,20 @@
+import { strSnakeCase } from '@nevware21/ts-utils'
+import { unique } from 'drizzle-orm/pg-core'
+
+import { addExtraConfig } from './addExtraConfig.ts'
+import type { FunctionRequiringColumnsMap } from './FunctionRequiringColumnsMap.ts'
+import { getCompressedIdentifierName } from './getCompressedIdentifierName.ts'
+
+export const addUniqueConstraintWithIndex =
+  <const TColumnNames extends [string, ...string[]]>(
+    ...columnNames: TColumnNames
+  ): FunctionRequiringColumnsMap<TColumnNames[number]> =>
+  args =>
+    addExtraConfig(table => [
+      unique(
+        getCompressedIdentifierName('UQ', [
+          args[0],
+          ...columnNames.map(name => strSnakeCase(table[name]?.name || name)),
+        ]),
+      ).on(...(columnNames.map(columnName => table[columnName]) as [any])),
+    ])(args)

package/src/extraTableConfigsAdders/getCompressedIdentifierName.ts

@@ -0,0 +1,24 @@
+export function getCompressedIdentifierName(prefix: string, tokens: string[]) {
+  {
+    const wide = prefix + '_' + tokens.join('_')
+    if (wide.length <= 63) return wide
+  }
+  tokens = tokens.flatMap(e => e.split('_')).filter(Boolean)
+  const render = () =>
+    prefix + '_' + tokens.map(e => e[0]?.toUpperCase() + e.slice(1)).join('')
+  let rendered = render()
+
+  while (rendered.length > 63) {
+    const maxLength = Math.max(...tokens.map(e => e.length))
+    if (maxLength === 1) {
+      rendered = rendered.slice(0, 63)
+      break
+    }
+    const index = tokens.findLastIndex(e => e.length === maxLength)
+    if (index in tokens) tokens[index] = tokens[index]!.slice(0, 1)
+    else throw new Error('wtf in getCompressedIdentifierName')
+    rendered = render()
+  }
+
+  return rendered
+}

package/src/extraTableConfigsAdders/index.ts

@@ -0,0 +1,9 @@
+export * from './addCompositeFk.ts'
+export * from './addCompositePrimaryKey.ts'
+export * from './addExtraConfig.ts'
+export * from './addFk.ts'
+export * from './addPrimaryKey.ts'
+export * from './addUniqueConstraintWithIndex.ts'
+export * from './ForeignTableColumnGetter.ts'
+export * from './FunctionRequiringColumnsMap.ts'
+export * from './getCompressedIdentifierName.ts'

package/src/finalizePgTable.ts

@@ -0,0 +1,22 @@
+import { strCamelCase } from '@nevware21/ts-utils'
+import { pgTable } from 'drizzle-orm/pg-core'
+import type { CamelCase } from 'type-fest'
+
+import type { GeneralColumnMap } from './columnsAdders/AllowOnlyValidColumnMaps.ts'
+import type { TableFuncArgs } from './TableFuncArgs.ts'
+
+export const finalizePgTable = <
+  const TTableName extends string,
+  TColumnsMap extends GeneralColumnMap = GeneralColumnMap,
+>(
+  args: TableFuncArgs<TTableName, TColumnsMap>,
+) => {
+  const table = pgTable(...args)
+
+  const exportName = strCamelCase(args[0])
+  type ExportName = CamelCase<TTableName>
+
+  return { [exportName]: table } as {
+    [key in ExportName]: typeof table
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './columnsAdders/index.ts'
+export * from './columnsWithExtraTableConfigsAdders/index.ts'
+export * from './extraTableConfigsAdders/index.ts'
+export * from './finalizePgTable.ts'
+export * from './initPgTable.ts'

package/src/initPgTable.ts

@@ -0,0 +1,5 @@
+import type { TableFuncArgs } from './TableFuncArgs.ts'
+
+export const initPgTable = <const TTableName extends string>(
+  snakeCaseTableName: TTableName,
+): TableFuncArgs<TTableName, {}> => [snakeCaseTableName, {}, () => []]