@planet-matrix/mobius-model 0.5.0 → 0.9.0

package/src/css/class.ts

@@ -0,0 +1,559 @@
+/**
+ * 表示以空格分隔的 CSS 类名字串。
+ */
+export type ClassString = string
+
+/**
+ * 表示按顺序保存的 CSS 类名数组。
+ */
+export type ClassArray = string[]
+
+/**
+ * 表示以类名为键、以启用状态为值的 CSS 类名对象。
+ *
+ * 该表示允许保留值为 `false` 的键，以表达已知但当前未启用的类名状态。
+ */
+export type ClassObject = Record<string, boolean>
+
+/**
+ * 表示 CSS 类名的三种公共表达形式：字符串、数组或对象。
+ */
+export type ClassUnion = ClassString | ClassArray | ClassObject
+
+/**
+ * 规范化类名字串，使其适合作为统一的字符串表示。
+ *
+ * 该函数会将 `.` 视为分隔符，将连续空白折叠为一个空格，并移除首尾空白。
+ *
+ * @example
+ * ```
+ * // Expect: 'mobius-base mobius-theme--light'
+ * const example1 = neatenClassString('mobius-base mobius-theme--light')
+ *
+ * // Expect: 'mobius-base mobius-theme--light'
+ * const example2 = neatenClassString('.mobius-base.mobius-theme--light')
+ *
+ * // Expect: 'mobius-base mobius-theme--light'
+ * const example3 = neatenClassString('  .mobius-base   mobius-theme--light  ')
+ * ```
+ */
+export const neatenClassString = (str: string): ClassString => {
+  const classString = str.replaceAll('.', ' ').replaceAll(/\s+/g, ' ').trim()
+  return classString
+}
+
+/**
+ * 将类名字串转换为类名数组。
+ *
+ * 输入会先经过 `neatenClassString` 规范化，再按空格拆分，并移除空项。
+ *
+ * @example
+ * ```
+ * // Expect: ['mobius-base', 'mobius-theme--light']
+ * const example1 = classStringToClassArray('mobius-base mobius-theme--light')
+ *
+ * // Expect: ['mobius-base', 'mobius-theme--light']
+ * const example2 = classStringToClassArray('.mobius-base.mobius-theme--light')
+ *
+ * // Expect: ['mobius-base', 'mobius-theme--light']
+ * const example3 = classStringToClassArray('  .mobius-base   mobius-theme--light  ')
+ * ```
+ */
+export const classStringToClassArray = (str: ClassString): ClassArray => {
+  const classArray = neatenClassString(str).split(' ').filter(s => s.length !== 0)
+  return classArray
+}
+
+/**
+ * 将类名数组转换为布尔对象表示。
+ *
+ * 数组中的每个非空类名都会映射为值为 `true` 的对象键。
+ *
+ * @example
+ * ```
+ * // Expect: { 'mobius-base': true, 'mobius-theme--light': true }
+ * const example1 = classArrayToClassObject(['mobius-base', 'mobius-theme--light'])
+ *
+ * // Expect: { 'mobius-base': true }
+ * const example2 = classArrayToClassObject(['mobius-base', ''])
+ *
+ * // Expect: {}
+ * const example3 = classArrayToClassObject([])
+ * ```
+ */
+export const classArrayToClassObject = (arr: ClassArray): ClassObject => {
+  const classObject: ClassObject = {}
+  arr.filter(s => s.length !== 0).forEach(s => {
+    classObject[s] = true
+  })
+  return classObject
+}
+
+/**
+ * 将类名字串直接转换为布尔对象表示。
+ *
+ * 该函数会先把字符串拆分为类名数组，再将每个类名映射为值为 `true` 的对象键。
+ *
+ * @example
+ * ```
+ * // Expect: { 'mobius-base': true, 'mobius-theme--light': true }
+ * const example1 = classStringToClassObject('mobius-base mobius-theme--light')
+ *
+ * // Expect: { 'mobius-base': true, 'mobius-theme--light': true }
+ * const example2 = classStringToClassObject('.mobius-base.mobius-theme--light')
+ * ```
+ */
+export const classStringToClassObject = (str: ClassString): ClassObject => {
+  const classArray = classStringToClassArray(str)
+  const classObject = classArrayToClassObject(classArray)
+  return classObject
+}
+
+/**
+ * 将布尔对象表示转换为类名数组。
+ *
+ * 值为 `false` 的类名和空类名会被忽略。
+ *
+ * @example
+ * ```
+ * // Expect: ['active', 'primary']
+ * const example1 = classObjectToClassArray({ active: true, disabled: false, primary: true })
+ *
+ * // Expect: ['active']
+ * const example2 = classObjectToClassArray({ '': true, active: true, disabled: false })
+ * ```
+ */
+export const classObjectToClassArray = (obj: ClassObject): ClassArray => {
+  const classArray: string[] = []
+  Object.entries(obj)
+    .filter(([key, value]) => key.length !== 0 && value)
+    .forEach(([key, _]) => {
+      classArray.push(key)
+    })
+  return classArray
+}
+
+/**
+ * 将类名数组按空格连接为类名字串。
+ *
+ * 空字符串项会被过滤，以避免产生多余空格。
+ *
+ * @example
+ * ```
+ * // Expect: 'mobius-base mobius-theme--light'
+ * const example1 = classArrayToClassString(['mobius-base', 'mobius-theme--light'])
+ *
+ * // Expect: 'mobius-base mobius-theme--light'
+ * const example2 = classArrayToClassString(['mobius-base', '', 'mobius-theme--light'])
+ * ```
+ */
+export const classArrayToClassString = (arr: ClassArray): ClassString => {
+  const classString = arr.filter(s => s.length !== 0).join(' ')
+  return classString
+}
+
+/**
+ * 将布尔对象表示转换为类名字串。
+ *
+ * 该函数会忽略值为 `false` 的类名和空类名，并保留其余类名的迭代顺序。
+ *
+ * @example
+ * ```
+ * // Expect: 'active primary'
+ * const example1 = classObjectToClassString({ active: true, disabled: false, primary: true })
+ *
+ * // Expect: 'active'
+ * const example2 = classObjectToClassString({ '': true, active: true, disabled: false })
+ * ```
+ */
+export const classObjectToClassString = (obj: ClassObject): ClassString => {
+  const classArray = classObjectToClassArray(obj)
+  const classString = classArrayToClassString(classArray)
+  return classString
+}
+
+/**
+ * 将任意公共类名表示转换为字符串表示。
+ *
+ * 如果输入本身已经是字符串，则原样返回；数组和对象会分别经过对应的序列化流程。
+ *
+ * @example
+ * ```
+ * // Expect: '  .button   active  '
+ * const example1 = toClassString('  .button   active  ')
+ *
+ * // Expect: 'button active'
+ * const example2 = toClassString(['button', 'active'])
+ *
+ * // Expect: 'button active'
+ * const example3 = toClassString({ button: true, active: true, disabled: false })
+ * ```
+ */
+export const toClassString = (tar: ClassUnion): ClassString => {
+  if (typeof tar === 'string') {
+    return tar
+  } else if (Array.isArray(tar)) {
+    return classArrayToClassString(tar)
+  } else {
+    return classObjectToClassString(tar)
+  }
+}
+
+/**
+ * 将任意公共类名表示转换为数组表示。
+ *
+ * 如果输入本身已经是数组，则会在过滤空类名后返回一个浅拷贝，以避免调用方共享同一数组实例。
+ *
+ * @example
+ * ```
+ * // Expect: ['button', 'active']
+ * const example1 = toClassArray('button active')
+ *
+ * // Expect: ['button', 'active']
+ * const example2 = toClassArray(['button', 'active'])
+ *
+ * // Expect: ['button', 'active']
+ * const example3 = toClassArray({ button: true, disabled: false, active: true })
+ * ```
+ */
+export const toClassArray = (tar: ClassUnion): ClassArray => {
+  if (typeof tar === 'string') {
+    return classStringToClassArray(tar)
+  } else if (Array.isArray(tar)) {
+    return tar.filter(s => s.length !== 0)
+  } else {
+    return classObjectToClassArray(tar)
+  }
+}
+
+/**
+ * 将任意公共类名表示转换为对象表示。
+ *
+ * 如果输入本身已经是对象，则会在过滤空类名后返回一个浅拷贝，以避免外部直接共享内部结果。
+ *
+ * @example
+ * ```
+ * // Expect: { button: true, active: true }
+ * const example1 = toClassObject('button active')
+ *
+ * // Expect: { button: true, active: true }
+ * const example2 = toClassObject(['button', 'active'])
+ *
+ * // Expect: { button: true, active: false }
+ * const example3 = toClassObject({ button: true, active: false, '': true })
+ * ```
+ */
+export const toClassObject = (tar: ClassUnion): ClassObject => {
+  if (typeof tar === 'string') {
+    return classStringToClassObject(tar)
+  } else if (Array.isArray(tar)) {
+    return classArrayToClassObject(tar)
+  } else {
+    const classObject: ClassObject = {}
+    Object.entries(tar).forEach(([key, value]) => {
+      if (key.length !== 0) {
+        classObject[key] = value
+      }
+    })
+    return classObject
+  }
+}
+
+/**
+ * 按目标值的外部表示，将类名集合格式化为相同形态。
+ *
+ * 该函数适合在内部统一按对象进行计算后，再把结果还原为调用方原本使用的表示。
+ *
+ * @example
+ * ```
+ * // Expect: 'button active'
+ * const example1 = formatClassToTarget('', ['button', 'active'])
+ *
+ * // Expect: ['button', 'active']
+ * const example2 = formatClassToTarget([], 'button active')
+ *
+ * // Expect: { button: true, active: true }
+ * const example3 = formatClassToTarget({}, ['button', 'active'])
+ * ```
+ */
+export const formatClassToTarget = <T extends ClassUnion>(target: T, cls: ClassUnion): T => {
+  if (typeof target === 'string') {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return toClassString(cls) as T
+  } else if (Array.isArray(target)) {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return toClassArray(cls) as T
+  } else {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return toClassObject(cls) as T
+  }
+}
+
+/**
+ * 为类名集合中的每一项补上指定前缀。
+ *
+ * 已经带有该前缀的类名会保持不变。
+ *
+ * @example
+ * ```
+ * // Expect: 'pm-button pm-active'
+ * const example1 = prefixClassWith('pm-', 'button active')
+ *
+ * // Expect: ['pm-button', 'pm-active']
+ * const example2 = prefixClassWith('pm-', ['button', 'pm-active'])
+ *
+ * // Expect: { 'pm-button': true, 'pm-active': true }
+ * const example3 = prefixClassWith('pm-', { button: true, 'pm-active': true })
+ * ```
+ */
+export const prefixClassWith = <T extends ClassUnion>(prefix: string, cls: T): T => {
+  if (typeof cls === 'string') {
+    const classArray = classStringToClassArray(cls).map(item =>
+      item.startsWith(prefix) ? item : `${prefix}${item}`
+    )
+    const classString = classArrayToClassString(classArray)
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return classString as T
+  } else if (Array.isArray(cls)) {
+    const classArray = cls.filter(item => item.length !== 0).map(item =>
+      item.startsWith(prefix) ? item : `${prefix}${item}`
+    )
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return classArray as T
+  } else {
+    const classObject: ClassObject = {}
+    Object.entries(cls).forEach(([key, value]) => {
+      if (key.length === 0) {
+        return
+      }
+      const _key = key.startsWith(prefix) ? key : `${prefix}${key}`
+      classObject[_key] = value === true
+    })
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return classObject as T
+  }
+}
+
+/**
+ * 从类名集合中的每一项移除指定前缀。
+ *
+ * 不带该前缀的类名会保持原样。
+ *
+ * @example
+ * ```
+ * // Expect: 'button active plain'
+ * const example1 = removePrefixOfClass('pm-', 'pm-button pm-active plain')
+ *
+ * // Expect: ['button', 'plain']
+ * const example2 = removePrefixOfClass('pm-', ['pm-button', 'plain'])
+ *
+ * // Expect: { button: true, plain: false }
+ * const example3 = removePrefixOfClass('pm-', { 'pm-button': true, plain: false, 'pm-': true })
+ * ```
+ */
+export const removePrefixOfClass = <T extends ClassUnion>(prefix: string, cls: T): T => {
+  if (typeof cls === 'string') {
+    const classArray = classStringToClassArray(cls).map(item => {
+      if (item.startsWith(prefix)) {
+        return item.slice(prefix.length)
+      }
+      return item
+    })
+    const classString = classArrayToClassString(classArray)
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return classString as T
+  } else if (Array.isArray(cls)) {
+    const classArray = cls.filter(item => item.length !== 0).map(item => {
+      if (item.startsWith(prefix)) {
+        return item.slice(prefix.length)
+      }
+      return item
+    })
+    const filteredClassArray = classArray.filter(item => item.length !== 0)
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return filteredClassArray as T
+  } else {
+    const classObject: ClassObject = {}
+    Object.entries(cls).forEach(([key, value]) => {
+      if (key.length === 0) {
+        return
+      }
+      const _key = key.startsWith(prefix) ? key.slice(prefix.length) : key
+      if (_key.length !== 0) {
+        classObject[_key] = value === true
+      }
+    })
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return classObject as T
+  }
+}
+
+/**
+ * 向目标类名集合中加入新的类名。
+ *
+ * 当目标与新增项都包含同名类时，以新增项转换后的对象表示为准。
+ *
+ * @example
+ * ```
+ * // Expect: 'button active primary'
+ * const example1 = addClass('button', 'active primary')
+ *
+ * // Expect: ['button', 'active', 'primary']
+ * const example2 = addClass(['button'], { active: true, primary: true })
+ * ```
+ */
+export const addClass = <T extends ClassUnion>(target: T, added: ClassUnion): T => {
+  const targetClassObj = toClassObject(target)
+  const addedClassObj = toClassObject(added)
+  const resClassObj = { ...targetClassObj, ...addedClassObj }
+  const result = formatClassToTarget(target, resClassObj)
+  return result
+}
+
+/**
+ * 从目标类名集合中移除指定类名。
+ *
+ * 该函数会把待移除项标记为 `false`，再按目标形态输出结果。
+ *
+ * @example
+ * ```
+ * // Expect: 'button primary'
+ * const example1 = removeClass('button active primary', 'active')
+ *
+ * // Expect: { button: true, active: false }
+ * const example2 = removeClass({ button: true, active: true }, ['active'])
+ * ```
+ */
+export const removeClass = <T extends ClassUnion>(target: T, removed: ClassUnion): T => {
+  const targetClassObj = toClassObject(target)
+  const removedClassObj = toClassObject(removed)
+  Object.keys(removedClassObj).forEach(key => {
+    removedClassObj[key] = false
+  })
+  const resClassObj = { ...targetClassObj, ...removedClassObj }
+  const result = formatClassToTarget(target, resClassObj)
+  return result
+}
+
+/**
+ * 切换目标类名集合中指定类名的启用状态。
+ *
+ * 已存在的类名会被关闭，不存在的类名会被开启。
+ *
+ * @example
+ * ```
+ * // Expect: 'button primary'
+ * const example1 = toggleClass('button active', 'active primary')
+ *
+ * // Expect: { button: true, primary: true }
+ * const example2 = toggleClass({ button: true, active: true }, ['active', 'primary'])
+ * ```
+ */
+export const toggleClass = <T extends ClassUnion>(target: T, toggled: ClassUnion): T => {
+  const targetClassObj = toClassObject(target)
+  const toggledClassArr = toClassArray(toggled)
+  toggledClassArr.forEach((cls) => {
+    // oxlint-disable-next-line strict-boolean-expressions
+    targetClassObj[cls] = !targetClassObj[cls]
+  })
+  const result = formatClassToTarget(target, targetClassObj)
+  return result
+}
+
+/**
+ * 替换目标类名集合中的类名。
+ *
+ * `replaced` 支持三种形式：
+ * - 字符串：仅移除对应类名。
+ * - 字符串数组：逐项移除对应类名。
+ * - 元组数组：按 `[from, to]` 的形式逐项替换类名。
+ * - 对象：按键值对执行替换，值为空字符串时表示删除。
+ *
+ * @example
+ * ```
+ * // Expect: 'button selected'
+ * const example1 = replaceClass('button active', [['active', 'selected']])
+ *
+ * // Expect: ['button', 'selected']
+ * const example2 = replaceClass(['button', 'active'], { active: 'selected' })
+ *
+ * // Expect: { button: true, active: false }
+ * const example3 = replaceClass({ button: true, active: true }, 'active')
+ * ```
+ */
+export const replaceClass = <T extends ClassUnion>(
+  target: T,
+  replaced: Record<string, string> | string | string[] | Array<[string, string]>,
+): T => {
+  if (typeof replaced === 'string') {
+    return removeClass(target, replaced)
+  }
+
+  const targetClassObj = toClassObject(target)
+
+  if (Array.isArray(replaced)) {
+    for (const item of replaced) {
+      if (typeof item === 'string') {
+        const fromValue = targetClassObj[item]
+
+        if (fromValue !== undefined) {
+          // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+          delete targetClassObj[item]
+        }
+
+        continue
+      }
+
+      const [from, to] = item
+      const fromValue = targetClassObj[from]
+
+      if (fromValue !== undefined) {
+        if (to !== '') {
+          targetClassObj[to] = fromValue
+        }
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete targetClassObj[from]
+      }
+    }
+
+    return formatClassToTarget(target, targetClassObj)
+  }
+
+  for (const [from, rawTo] of Object.entries(replaced)) {
+    if (typeof rawTo !== 'string') {
+      continue
+    }
+
+    const fromValue = targetClassObj[from]
+
+    if (fromValue !== undefined) {
+      if (rawTo !== '') {
+        targetClassObj[rawTo] = fromValue
+      }
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete targetClassObj[from]
+    }
+  }
+
+  return formatClassToTarget(target, targetClassObj)
+}
+
+/**
+ * 判断目标类名集合是否完整包含另一组类名。
+ *
+ * 只有当 `contained` 中的每个类名都存在于 `target` 中时，才会返回 `true`。
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * const example1 = containClass('button active', 'button active primary')
+ *
+ * // Expect: false
+ * const example2 = containClass(['button', 'missing'], { button: true, active: true })
+ * ```
+ */
+export const containClass = (contained: ClassUnion, target: ClassUnion): boolean => {
+  const containedClassArr = toClassArray(contained)
+  const targetClassArr = toClassArray(target)
+  return containedClassArr.every(item => targetClassArr.includes(item))
+}

package/src/css/index.ts

@@ -0,0 +1 @@
+export * from "./class.ts"

package/src/drizzle/README.md

@@ -0,0 +1 @@
+# Drizzle

package/src/drizzle/drizzle.ts

@@ -0,0 +1 @@
+export * as d from "drizzle-orm"

package/src/drizzle/helper.ts

@@ -0,0 +1,47 @@
+import type { ExtractTablesWithRelations } from "drizzle-orm"
+import { PgDatabase, PgTransaction } from "drizzle-orm/pg-core"
+import type {
+  PostgresJsDatabase as RawPostgresJsDatabase,
+  PostgresJsTransaction as RawPostgresJsTransaction,
+} from "drizzle-orm/postgres-js"
+
+export type PostgresJsNormalDatabase<Schema extends Record<string, unknown> = Record<string, never>>
+  = RawPostgresJsDatabase<Schema>
+export type PostgresJsTransactionDatabase<Schema extends Record<string, unknown> = Record<string, never>>
+  = RawPostgresJsTransaction<Schema, ExtractTablesWithRelations<Schema>>
+export type PostgresJsDatabase<Schema extends Record<string, unknown> = Record<string, never>>
+  = PostgresJsNormalDatabase<Schema> | PostgresJsTransactionDatabase<Schema>
+export interface WithPostgresJsDatabase<Schema extends Record<string, unknown> = Record<string, never>> {
+  database: PostgresJsDatabase<Schema>
+}
+export interface WithOptionalPostgresJsDatabase<Schema extends Record<string, unknown> = Record<string, never>> {
+  database?: PostgresJsDatabase<Schema> | undefined
+}
+export type WithoutPostgresJsDatabase<T> = Omit<T, "database">
+
+export const isPostgresJsNormalDatabase = <Schema extends Record<string, unknown> = Record<string, never>>(
+  database: PostgresJsDatabase<Schema>,
+): database is PostgresJsNormalDatabase<Schema> => {
+  return database instanceof PgDatabase
+}
+export const isPostgresJsTransactionDatabase = <Schema extends Record<string, unknown> = Record<string, never>>(
+  database: PostgresJsDatabase<Schema>,
+): database is PostgresJsTransactionDatabase<Schema> => {
+  return database instanceof PgTransaction
+}
+export const autoPostgresJsDatabaseTransaction = async <Result, Schema extends Record<string, unknown> = Record<string, never>>(
+  database: PostgresJsDatabase<Schema>,
+  run: (database: PostgresJsTransactionDatabase<Schema>) => Promise<Result>,
+): Promise<Result> => {
+  // detect transaction database first, then normal database
+  // because transaction database is a subclass of normal database
+  if (isPostgresJsTransactionDatabase(database)) {
+    return await run(database)
+  }
+  if (isPostgresJsNormalDatabase(database)) {
+    return await database.transaction(async (database) => {
+      return await run(database)
+    })
+  }
+  throw new Error("Invalid database instance")
+}

package/src/drizzle/index.ts

@@ -0,0 +1,5 @@
+export * from "./drizzle.ts"
+export type * from "./infer.ts"
+export type * from "./kysely.ts"
+export * from "./pagination.ts"
+export * from "./helper.ts"

package/src/drizzle/infer.ts

@@ -0,0 +1,52 @@
+import type { DrizzleTypeError, InferEnum, InferInsertModel, InferSelectModel } from "drizzle-orm"
+import type { PgEnum, PgTableWithColumns } from "drizzle-orm/pg-core"
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js"
+
+type RemoveNeverValue<T> = {
+  [K in keyof T as T[K] extends never ? never : K]: T[K]
+}
+
+type PreInferModel<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T]: T[K] extends PgTableWithColumns<infer _>
+  ? InferSelectModel<T[K]>
+  : (
+    T[K] extends PgEnum<infer __>
+    ? InferEnum<T[K]>
+    : never
+  )
+}
+export type InferModel<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferModel<T>>
+
+type PreInferInsert<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T]: T[K] extends PgTableWithColumns<infer _>
+  ? InferInsertModel<T[K]>
+  : never
+}
+export type InferInsert<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferInsert<T>>
+
+type PreInferUpdate<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T]: T[K] extends PgTableWithColumns<infer _>
+  ? Partial<InferSelectModel<T[K]>>
+  : (
+    T[K] extends PgEnum<infer __>
+    ? InferEnum<T[K]>
+    : never
+  )
+}
+export type InferUpdate<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferUpdate<T>>
+
+type GetValidQuery<T extends Record<string, unknown> = Record<string, never>> = Exclude<
+  PostgresJsDatabase<T>["query"],
+  DrizzleTypeError<string>
+>
+type PreInferWith<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof GetValidQuery<T>]: NonNullable<NonNullable<Parameters<GetValidQuery<T>[K]["findMany"]>[0]>["with"]>
+}
+export type InferWith<T extends Record<string, unknown> = Record<string, never>> = RemoveNeverValue<PreInferWith<T>>
+
+// oxlint-disable-next-line typescript/no-explicit-any
+export type AnyPgTableWithColumns = PgTableWithColumns<any>
+type PreInferModelFromPgTableWithColumns<T extends AnyPgTableWithColumns> = {
+  [K in keyof InferSelectModel<T>]: InferSelectModel<T>[K]
+}
+export type InferModelFromPgTableWithColumns<T extends AnyPgTableWithColumns> = RemoveNeverValue<PreInferModelFromPgTableWithColumns<T>>

package/src/drizzle/kysely.ts

@@ -0,0 +1,8 @@
+import type { Table } from "drizzle-orm"
+import type { Kyselify } from "drizzle-orm/kysely"
+import type { AnyPgTable } from "drizzle-orm/pg-core"
+
+export type KyselifyTable<T extends Table> = Kyselify<T>
+export type KyselifyDatabase<T extends Record<string, unknown> = Record<string, never>> = {
+  [K in keyof T as T[K] extends AnyPgTable ? T[K]["_"]["name"] : never]: T[K] extends AnyPgTable ? Kyselify<T[K]> : never
+}