drizzle-fp 0.1.0

package/dist-types/src/finalizePgTable.d.ts

@@ -0,0 +1,130 @@
+import type { CamelCase } from 'type-fest';
+import type { GeneralColumnMap } from './columnsAdders/AllowOnlyValidColumnMaps.ts';
+import type { TableFuncArgs } from './TableFuncArgs.ts';
+export declare const finalizePgTable: <const TTableName extends string, TColumnsMap extends GeneralColumnMap = GeneralColumnMap>(args: TableFuncArgs<TTableName, TColumnsMap>) => { [key in CamelCase<TTableName>]: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: TTableName;
+    schema: undefined;
+    columns: { [Key in keyof TColumnsMap]: import("drizzle-orm/pg-core").PgColumn<{
+        name: (Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        })["name"];
+        tableName: TTableName;
+        dataType: (Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        })["dataType"];
+        columnType: (Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        })["columnType"];
+        data: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T ? T extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T extends {
+            $type: infer U;
+        } ? U : T["data"] : never : never;
+        driverParam: (Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        })["driverParam"];
+        notNull: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_1 ? T_1 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_1 extends {
+            notNull: true;
+        } ? true : false : never : never;
+        hasDefault: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_2 ? T_2 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_2 extends {
+            hasDefault: true;
+        } ? true : false : never : never;
+        isPrimaryKey: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_3 ? T_3 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_3 extends {
+            isPrimaryKey: true;
+        } ? true : false : never : never;
+        isAutoincrement: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_4 ? T_4 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_4 extends {
+            isAutoincrement: true;
+        } ? true : false : never : never;
+        hasRuntimeDefault: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_5 ? T_5 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_5 extends {
+            hasRuntimeDefault: true;
+        } ? true : false : never : never;
+        enumValues: (Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        })["enumValues"];
+        baseColumn: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_6 ? T_6 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_6 extends {
+            baseBuilder: infer U_1 extends import("drizzle-orm").ColumnBuilderBase;
+        } ? import("drizzle-orm").Column<{
+            name: U_1["_"]["name"];
+            tableName: TTableName;
+            dataType: U_1["_"]["dataType"];
+            columnType: U_1["_"]["columnType"];
+            data: U_1["_"] extends infer T_7 ? T_7 extends U_1["_"] ? T_7 extends {
+                $type: infer U;
+            } ? U : T_7["data"] : never : never;
+            driverParam: U_1["_"]["driverParam"];
+            notNull: U_1["_"] extends infer T_8 ? T_8 extends U_1["_"] ? T_8 extends {
+                notNull: true;
+            } ? true : false : never : never;
+            hasDefault: U_1["_"] extends infer T_9 ? T_9 extends U_1["_"] ? T_9 extends {
+                hasDefault: true;
+            } ? true : false : never : never;
+            isPrimaryKey: U_1["_"] extends infer T_10 ? T_10 extends U_1["_"] ? T_10 extends {
+                isPrimaryKey: true;
+            } ? true : false : never : never;
+            isAutoincrement: U_1["_"] extends infer T_11 ? T_11 extends U_1["_"] ? T_11 extends {
+                isAutoincrement: true;
+            } ? true : false : never : never;
+            hasRuntimeDefault: U_1["_"] extends infer T_12 ? T_12 extends U_1["_"] ? T_12 extends {
+                hasRuntimeDefault: true;
+            } ? true : false : never : never;
+            enumValues: U_1["_"]["enumValues"];
+            baseColumn: U_1["_"] extends infer T_13 ? T_13 extends U_1["_"] ? T_13 extends {
+                baseBuilder: infer U_1 extends import("drizzle-orm").ColumnBuilderBase;
+            } ? import("drizzle-orm").Column</*elided*/ any, {}, Omit<U_1["_"], "brand" | "name" | "dataType" | "columnType" | "data" | "driverParam" | "notNull" | "hasDefault" | "enumValues" | "identity" | "generated" | "dialect" | "tableName" | "isPrimaryKey" | "isAutoincrement" | "hasRuntimeDefault" | "baseColumn"> extends infer T_14 ? { [K in keyof T_14]: T_14[K]; } : never> : never : never : never;
+            identity: U_1["_"] extends infer T_15 ? T_15 extends U_1["_"] ? T_15 extends {
+                identity: "always";
+            } ? "always" : T_15 extends {
+                identity: "byDefault";
+            } ? "byDefault" : undefined : never : never;
+            generated: U_1["_"] extends infer T_16 ? T_16 extends U_1["_"] ? T_16 extends {
+                generated: infer G;
+            } ? unknown extends G ? undefined : G extends undefined ? undefined : G : undefined : never : never;
+        }, {}, Omit<U_1["_"], "brand" | "name" | "dataType" | "columnType" | "data" | "driverParam" | "notNull" | "hasDefault" | "enumValues" | "identity" | "generated" | "dialect" | "tableName" | "isPrimaryKey" | "isAutoincrement" | "hasRuntimeDefault" | "baseColumn"> extends infer T_17 ? { [K in keyof T_17]: T_17[K]; } : never> : never : never : never;
+        identity: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_18 ? T_18 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_18 extends {
+            identity: "always";
+        } ? "always" : T_18 extends {
+            identity: "byDefault";
+        } ? "byDefault" : undefined : never : never;
+        generated: Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } extends infer T_19 ? T_19 extends Omit<TColumnsMap[Key]["_"], "name"> & {
+            name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+        } ? T_19 extends {
+            generated: infer G;
+        } ? unknown extends G ? undefined : G extends undefined ? undefined : G : undefined : never : never;
+    }, {}, Omit<Omit<TColumnsMap[Key]["_"], "name"> & {
+        name: TColumnsMap[Key]["_"]["name"] extends "" ? import("drizzle-orm").Assume<Key, string> : TColumnsMap[Key]["_"]["name"];
+    }, "brand" | "name" | "dataType" | "columnType" | "data" | "driverParam" | "notNull" | "hasDefault" | "enumValues" | "identity" | "generated" | "dialect" | "tableName" | "isPrimaryKey" | "isAutoincrement" | "hasRuntimeDefault" | "baseColumn"> extends infer T_20 ? { [K_1 in keyof T_20]: T_20[K_1]; } : never>; };
+    dialect: "pg";
+}>; };
+//# sourceMappingURL=finalizePgTable.d.ts.map

package/dist-types/src/finalizePgTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalizePgTable.d.ts","sourceRoot":"","sources":["../../src/finalizePgTable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAA;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,eAAO,MAAM,eAAe,GAC1B,KAAK,CAAC,UAAU,SAAS,MAAM,EAC/B,WAAW,SAAS,gBAAgB,GAAG,gBAAgB,EAEvD,MAAM,aAAa,CAAC,UAAU,EAAE,WAAW,CAAC,KAOV,GAC/B,GAAG,yBAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAErB,CAAA"}

package/dist-types/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './columnsAdders/index.ts';
+export * from './columnsWithExtraTableConfigsAdders/index.ts';
+export * from './extraTableConfigsAdders/index.ts';
+export * from './finalizePgTable.ts';
+export * from './initPgTable.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist-types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,+CAA+C,CAAA;AAC7D,cAAc,oCAAoC,CAAA;AAClD,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA"}

package/dist-types/src/initPgTable.d.ts

@@ -0,0 +1,3 @@
+import type { TableFuncArgs } from './TableFuncArgs.ts';
+export declare const initPgTable: <const TTableName extends string>(snakeCaseTableName: TTableName) => TableFuncArgs<TTableName, {}>;
+//# sourceMappingURL=initPgTable.d.ts.map

package/dist-types/src/initPgTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initPgTable.d.ts","sourceRoot":"","sources":["../../src/initPgTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,eAAO,MAAM,WAAW,GAAI,KAAK,CAAC,UAAU,SAAS,MAAM,EACzD,oBAAoB,UAAU,KAC7B,aAAa,CAAC,UAAU,EAAE,EAAE,CAAuC,CAAA"}

package/index.ts

@@ -0,0 +1 @@
+export * from './src/index.ts'

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "drizzle-fp",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Write drizzle table declarations in functional style, and make reusable table parts easily",
+  "devDependencies": {
+    "@effect/language-service": "^0.86.2",
+    "@evadev/tsconfig": "^1.0.1",
+    "@types/pg": "^8.15.6",
+    "ts-namespace-import": "nounder/ts-namespace-import",
+    "ts-patch": "^4.0.1",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "effect": "^3.19.16"
+  },
+  "dependencies": {
+    "@nevware21/ts-utils": "^0.14.0",
+    "drizzle-orm": "^0.45.0",
+    "pg": "^8.21.0",
+    "type-fest": "^5.4.4"
+  },
+  "homepage": "https://github.com/nikelborm/effect-garden/tree/main/packages/drizzle-fp#readme",
+  "bugs": {
+    "url": "https://github.com/nikelborm/effect-garden/issues",
+    "email": "evadev@duck.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/nikelborm/effect-garden.git",
+    "directory": "packages/drizzle-fp"
+  },
+  "scripts": {
+    "build": "tspc",
+    "dev": "tspc --watch"
+  },
+  "author": {
+    "name": "nikelborm",
+    "email": "evadev@duck.com",
+    "url": "https://github.com/nikelborm"
+  },
+  "contributors": [
+    {
+      "name": "nikelborm",
+      "email": "evadev@duck.com",
+      "url": "https://github.com/nikelborm"
+    }
+  ],
+  "maintainers": [
+    {
+      "name": "nikelborm",
+      "email": "evadev@duck.com",
+      "url": "https://github.com/nikelborm"
+    }
+  ],
+  "license": "MIT",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "exports": {
+    ".": {
+      "types": "./dist-types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*.js": {
+      "types": "./dist-types/src/*.d.ts",
+      "default": "./dist/src/*.js"
+    },
+    "./*.ts": "./src/*.ts",
+    "./*": {
+      "types": "./dist-types/src/*.d.ts",
+      "default": "./dist/src/*.js"
+    },
+    "./internal/*": null,
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist-types/index.d.ts",
+  "files": [
+    "dist-types",
+    "dist",
+    "index.ts",
+    "package.json",
+    "src",
+    "!**/*.spec.*",
+    "!**/*.tsbuildinfo",
+    "!**/scratchpad.*"
+  ]
+}

package/src/TableFuncArgs.ts

@@ -0,0 +1,21 @@
+import type { BuildIndexColumn } from 'drizzle-orm'
+import type { PgTableExtraConfigValue } from 'drizzle-orm/pg-core'
+
+import type { GeneralColumnMap } from './columnsAdders/index.ts'
+
+export type TableFuncArgs<
+  TTableName extends string,
+  TColumnsMap extends GeneralColumnMap = GeneralColumnMap,
+> = [
+  name: TTableName,
+  columns: TColumnsMap,
+  extraConfig: (
+    table: RemapToTableArgumentOfExtraConfigRenderer<TColumnsMap>,
+  ) => PgTableExtraConfigValue[],
+]
+
+export type RemapToTableArgumentOfExtraConfigRenderer<
+  TColumnsMap extends GeneralColumnMap = GeneralColumnMap,
+> = {
+  [Key in keyof TColumnsMap]: BuildIndexColumn<'pg'>
+}

package/src/columnsAdders/AllowOnlyValidColumnMaps.ts

@@ -0,0 +1,69 @@
+import type { PgColumnBuilderBase } from 'drizzle-orm/pg-core'
+
+const ErrorMessageBrand = Symbol()
+
+export type ErrMsg<Message extends string, Context = any> = {
+  message: Message
+  brand: typeof ErrorMessageBrand
+  context: Context
+}
+
+export type ColumnMap<Keys extends string> = Record<Keys, PgColumnBuilderBase>
+export type GeneralColumnMap = ColumnMap<string>
+
+// TODO: make all validation sound with runtime execution
+
+export type AllowOnlyNonEmptyObjectsWithActualKeys<
+  ValueToValidate,
+  ExpectedRecordValue = any,
+> = [
+  AllowOnlyNonEmptyLiteralStringKeys<AllowOnlyNonEmptyObjects<ValueToValidate>>,
+] extends [infer U extends ErrMsg<string>]
+  ? U
+  : Record<string, ExpectedRecordValue>
+
+type AllowOnlyNonEmptyLiteralStringKeys<ValueToValidate> =
+  ForbidEmptyStringKeys<
+    ForbidNonLiteralStringKeys<ForbidNonStringKeys<ValueToValidate>>
+  >
+
+type AllowOnlyNonEmptyObjects<ValueToValidate> = ForbidNonEmptyObject<
+  ForbidNonObjects<ValueToValidate>
+>
+
+type ForbidNonEmptyObject<ValueToValidate> = keyof ValueToValidate extends never
+  ? ErrMsg<'Cannot be empty object', ValueToValidate>
+  : ValueToValidate
+
+type ForbidNonLiteralStringKeys<ValueToValidate> =
+  string extends keyof ValueToValidate
+    ? ErrMsg<
+        'Object parameter keys cannot be general strings, they should be specific string literals',
+        ValueToValidate
+      >
+    : ValueToValidate
+
+type ForbidNonObjects<ValueToValidate> = [ValueToValidate] extends [
+  Record<symbol | string | number, any>,
+]
+  ? ValueToValidate
+  : ErrMsg<'Should be an object', ValueToValidate>
+
+type ForbidEmptyStringKeys<ValueToValidate> = keyof ValueToValidate extends ''
+  ? ErrMsg<'Object parameter keys cannot be empty string, ValueToValidate'>
+  : ValueToValidate
+
+type ForbidNonStringKeys<ValueToValidate> = keyof ValueToValidate extends
+  | number
+  | symbol
+  | boolean
+  | undefined
+  | null
+  ? ErrMsg<
+      'Object parameter keys should be only strings and only literals, and not number, symbol, boolean, undefined or null',
+      ValueToValidate
+    >
+  : ValueToValidate
+
+export type AllowOnlyValidColumnMaps<T> =
+  AllowOnlyNonEmptyObjectsWithActualKeys<T, PgColumnBuilderBase>

package/src/columnsAdders/FunctionExtendingColumnsMap.ts

@@ -0,0 +1,24 @@
+import type { TableFuncArgs } from '../TableFuncArgs.ts'
+import type {
+  AllowOnlyValidColumnMaps,
+  ErrMsg,
+  GeneralColumnMap,
+} from './AllowOnlyValidColumnMaps.ts'
+
+export type FunctionExtendingColumnsMap<TAdditionalColumnsMap> =
+  SwitchEitherToNeverOrToValueOnError<
+    AllowOnlyValidColumnMaps<TAdditionalColumnsMap>,
+    <
+      const TTableName extends string,
+      TColumnsMap extends GeneralColumnMap = GeneralColumnMap,
+    >([snakeCaseTableName, options, extraConfig]: TableFuncArgs<
+      TTableName,
+      TColumnsMap
+    >) => TableFuncArgs<TTableName, TAdditionalColumnsMap & TColumnsMap>
+  >
+
+type SwitchEitherToNeverOrToValueOnError<ValueToValidate, SuccessValue> = [
+  ValueToValidate,
+] extends [ErrMsg<string>]
+  ? never
+  : SuccessValue

package/src/columnsAdders/addColumn.ts

@@ -0,0 +1,14 @@
+import type { PgColumnBuilderBase } from 'drizzle-orm/pg-core'
+
+import { addColumns } from './addColumns.ts'
+import type { FunctionExtendingColumnsMap } from './FunctionExtendingColumnsMap.ts'
+
+export const addColumn = <
+  const NameOfColumnInCurrentTable extends string,
+  ColumnBuilder extends PgColumnBuilderBase,
+>(
+  nameOfColumnInCurrentTable: NameOfColumnInCurrentTable,
+  buildColumn: () => ColumnBuilder,
+): FunctionExtendingColumnsMap<{
+  [Key in NameOfColumnInCurrentTable]: ColumnBuilder
+}> => addColumns(() => ({ [nameOfColumnInCurrentTable]: buildColumn() }) as any)

package/src/columnsAdders/addColumns.ts

@@ -0,0 +1,18 @@
+import type { AllowOnlyValidColumnMaps } from './AllowOnlyValidColumnMaps.ts'
+import type { FunctionExtendingColumnsMap } from './FunctionExtendingColumnsMap.ts'
+
+export const addColumns = <
+  TAdditionalColumnsMap extends [TAdditionalColumnsMap] extends [infer U]
+    ? AllowOnlyValidColumnMaps<U>
+    : never,
+>(
+  getAdditionalColumnMap: () => TAdditionalColumnsMap,
+): FunctionExtendingColumnsMap<TAdditionalColumnsMap> =>
+  (([snakeCaseTableName, options, extraConfig]) => [
+    snakeCaseTableName,
+    {
+      ...options,
+      ...(getAdditionalColumnMap() as any),
+    },
+    table => extraConfig(table),
+  ]) as FunctionExtendingColumnsMap<TAdditionalColumnsMap>

package/src/columnsAdders/addHappenedAtDateColumns.ts

@@ -0,0 +1,24 @@
+import { timestamp } from 'drizzle-orm/pg-core'
+
+import { flow } from 'effect/Function'
+
+import { addColumn } from './addColumn.ts'
+
+const addHappenedAtDateColumn = <const TColumnName extends string>(
+  name: TColumnName,
+) =>
+  addColumn(name, () =>
+    timestamp({
+      withTimezone: true,
+      mode: 'string',
+    })
+      .defaultNow()
+      .notNull(),
+  )
+
+export const addCreatedAtDateColumn = addHappenedAtDateColumn('createdAt')
+
+export const addCreatedAndUpdatedDateColumns = flow(
+  addCreatedAtDateColumn,
+  addHappenedAtDateColumn('updatedAt'),
+)

package/src/columnsAdders/addRequiredColumn.ts

@@ -0,0 +1,20 @@
+import type { NotNull } from 'drizzle-orm'
+
+import {
+  addRequiredColumns,
+  type ColumnBuilderWithNotNullMethod,
+} from './addRequiredColumns.ts'
+import type { FunctionExtendingColumnsMap } from './FunctionExtendingColumnsMap.ts'
+
+export const addRequiredColumn = <
+  const NameOfColumnInCurrentTable extends string,
+  ColumnBuilder extends ColumnBuilderWithNotNullMethod,
+>(
+  nameOfColumnInCurrentTable: NameOfColumnInCurrentTable,
+  buildColumn: () => ColumnBuilder,
+): FunctionExtendingColumnsMap<{
+  [Key in NameOfColumnInCurrentTable]: NotNull<ColumnBuilder>
+}> =>
+  addRequiredColumns(
+    () => ({ [nameOfColumnInCurrentTable]: buildColumn() }) as any,
+  )

package/src/columnsAdders/addRequiredColumns.ts

@@ -0,0 +1,41 @@
+import type { NotNull } from 'drizzle-orm'
+import type { PgColumnBuilderBase } from 'drizzle-orm/pg-core'
+
+import type { AllowOnlyNonEmptyObjectsWithActualKeys } from './AllowOnlyValidColumnMaps.ts'
+import { addColumns } from './addColumns.ts'
+import type { FunctionExtendingColumnsMap } from './FunctionExtendingColumnsMap.ts'
+
+export const addRequiredColumns = <
+  const TAdditionalColumnsMap extends [TAdditionalColumnsMap] extends [infer U]
+    ? AllowOnlyNonEmptyObjectsWithActualKeys<U, ColumnBuilderWithNotNullMethod>
+    : never,
+>(
+  getAdditionalColumnMap: () => TAdditionalColumnsMap,
+): BuiltRequiredColumnsAdder<TAdditionalColumnsMap> =>
+  addColumns(
+    () =>
+      Object.fromEntries(
+        Object.entries(
+          getAdditionalColumnMap() as unknown as Record<
+            string,
+            ColumnBuilderWithNotNullMethod
+          >,
+        ).map(([ownColumnName, currentColumnBuilder]) => [
+          ownColumnName,
+          currentColumnBuilder.notNull(),
+        ]),
+      ) as any,
+  )
+
+type BuiltRequiredColumnsAdder<TAdditionalColumnsMap> =
+  FunctionExtendingColumnsMap<MakeColumnsInMapNotNull<TAdditionalColumnsMap>>
+
+type MakeColumnsInMapNotNull<TColumnsMap> = {
+  [ColumnName in keyof TColumnsMap]: TColumnsMap[ColumnName] extends PgColumnBuilderBase
+    ? NotNull<TColumnsMap[ColumnName]>
+    : never
+}
+
+export type ColumnBuilderWithNotNullMethod = PgColumnBuilderBase & {
+  notNull: () => NotNull<PgColumnBuilderBase>
+}

package/src/columnsAdders/addRequiredNameOrDescription.ts

@@ -0,0 +1,14 @@
+import { varchar } from 'drizzle-orm/pg-core'
+
+import { flow } from 'effect/Function'
+
+import { addColumn } from './addColumn.ts'
+import { addRequiredColumn } from './addRequiredColumn.ts'
+
+export const addRequiredName = addRequiredColumn('name', varchar)
+export const addOptionalDescription = addColumn('description', varchar)
+
+export const addRequiredNameWithOptionalDescription = flow(
+  addRequiredName,
+  addOptionalDescription,
+)

package/src/columnsAdders/index.ts

@@ -0,0 +1,9 @@
+export * from './AllowOnlyValidColumnMaps.ts'
+export * from './addColumn.ts'
+export * from './addColumns.ts'
+export * from './addHappenedAtDateColumns.ts'
+export * from './addRequiredColumn.ts'
+export * from './addRequiredColumns.ts'
+export * from './addRequiredNameOrDescription.ts'
+export * from './FunctionExtendingColumnsMap.ts'
+export * from './nonNullIdentity.ts'

package/src/columnsAdders/nonNullIdentity.ts

@@ -0,0 +1,11 @@
+import { bigint, integer, text, uuid } from 'drizzle-orm/pg-core'
+
+export const nonNullInteger = () => integer().notNull()
+export const nonNullBigint53 = () => bigint({ mode: 'number' }).notNull()
+export const nonNullUuid = () => uuid().notNull()
+export const nonNullText = () => text().notNull()
+
+export type NonNullInteger = ReturnType<typeof nonNullInteger>
+export type NonNullBigint53 = ReturnType<typeof nonNullBigint53>
+export type NonNullUUID = ReturnType<typeof nonNullUuid>
+export type NonNullText = ReturnType<typeof nonNullText>

package/src/columnsWithExtraTableConfigsAdders/addAutoGeneratedGloballyUniqueOrderingColumn.ts

@@ -0,0 +1,13 @@
+import { serial } from 'drizzle-orm/pg-core'
+
+import { flow } from 'effect/Function'
+
+import { addRequiredColumn } from '../columnsAdders/index.ts'
+import { addUniqueConstraintWithIndex } from '../extraTableConfigsAdders/index.ts'
+
+// TODO: Add also Bigint53 version
+
+export const addAutoGeneratedGloballyUniqueOrderingColumn = flow(
+  addRequiredColumn('order', serial),
+  addUniqueConstraintWithIndex('order'),
+)

package/src/columnsWithExtraTableConfigsAdders/addBigint53IdColumnAsPrimaryKey.ts

@@ -0,0 +1,30 @@
+import type { IsIdentity, NotNull } from 'drizzle-orm'
+import type { PgBigInt53BuilderInitial } from 'drizzle-orm/pg-core'
+import { bigint } from 'drizzle-orm/pg-core'
+
+import { pipe } from 'effect/Function'
+
+import { addColumn, type GeneralColumnMap } from '../columnsAdders/index.ts'
+import { addPrimaryKey } from '../extraTableConfigsAdders/index.ts'
+import type { TableFuncArgs } from '../TableFuncArgs.ts'
+
+export const addBigint53IdColumnAsPrimaryKey = <
+  const TTableName extends string,
+  TColumnsMap extends GeneralColumnMap,
+>(
+  args: TableFuncArgs<TTableName, TColumnsMap>,
+): TableFuncArgs<
+  TTableName,
+  TColumnsMap & { id: PgBigint53GeneratedAlwaysAsIdentity<TTableName> }
+> =>
+  pipe(
+    addColumn('id', () =>
+      bigint(`${args[0]}_id`, {
+        mode: 'number',
+      }).generatedAlwaysAsIdentity(),
+    )(args),
+    addPrimaryKey('id'),
+  )
+
+type PgBigint53GeneratedAlwaysAsIdentity<TTableName extends string> =
+  IsIdentity<NotNull<PgBigInt53BuilderInitial<`${TTableName}_id`>>, 'always'>

package/src/columnsWithExtraTableConfigsAdders/addBigint53RequiredColumnWithFk.ts

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

package/src/columnsWithExtraTableConfigsAdders/addBigint53RequiredColumnsWithCompositeFk.ts

@@ -0,0 +1,26 @@
+import type { AnyPgTable } from 'drizzle-orm/pg-core'
+
+import {
+  type AllowOnlyNonEmptyObjectsWithActualKeys,
+  type FunctionExtendingColumnsMap,
+  type NonNullBigint53,
+  nonNullBigint53,
+} from '../columnsAdders/index.ts'
+import { addColumnsOfTheSameTypeWithCompositeFk } from './addColumnsOfTheSameTypeWithCompositeFk.ts'
+
+export const addBigint53RequiredColumnsWithCompositeFk = <
+  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>, NonNullBigint53>
+> =>
+  addColumnsOfTheSameTypeWithCompositeFk(
+    getForeignTable,
+    nonNullBigint53,
+    fkConfig,
+  )

package/src/columnsWithExtraTableConfigsAdders/addBigint53RequiredColumnsWithCompositeFk1to1.ts

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