Shorthand way to pass the entire update object inside of doUpdateSet when updating multiple values.

const countries = [
    { id: 1, name: 'UK', continent: 'Europe' },
    { id: 2, name: 'France', continent: 'Europe' }
];

await db.insertInto('countries')
    .values(countries)
    .onConflict(oc => oc
        .column('id')
        .doUpdateSet(eb => ({
            name: eb.ref('excluded.name'),
            continent: eb.ref('excluded.continent')
        }))
    )
    .execute();

export const updateAllSet = <DB, TB extends keyof DB, V extends Insertable<DB[TB]>>(
    record: V
): UpdateObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>> =>
    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
    pipe(
        record,
        R.mapWithIndex(
            column => (eb: ExpressionBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>) =>
                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                eb.ref(`excluded.${column}` as StringReference<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>)
        )
    ) as UpdateObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>

await db.insertInto('countries')
    .values([{ id: 1, name: 'France', continent: 'Europe' }])
    .onConflict(oc => updateAllSet(oc))
    .execute();

await db.insertInto('countries')
    .values([{ id: 1, name: 'France', continent: 'Europe' }])
    .onConflict(oc => oc
        .column('id')
        .doUpdateSet(updateAllSet(oc))
    )
    .execute();

const values = [{ id: 1, name: 'France', continent: 'Europe' }]
await db.insertInto('countries')
    .values(values)
    .onConflict(oc => oc
        .column('id')
        .doUpdateSet(updateAllSet(values[0]))
    )
    .execute();

const record = { a: "hello", b: 42 }
const updateAllSet = (r) => {
   const entries = Object.entries(r)
   const mapped = entries.map(([k,v]) => [k, (eb) => eb.ref('excluded.${k}')])
   return Object.fromEntries(mapped) 
}

function updateAllSet<DB, TB extends keyof DB, V extends Array<Insertable<DB[TB]>>>(records: V) {
    return Object.keys(records[0])
        .reduce<UpdateObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>>((acc, key) => {
            return {
                ...acc,
                [key]: (eb: ExpressionBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>) =>
                    eb.ref(`excluded.${key as string}` as StringReference<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>)
            };
        }, {});
}

doUpdateSet(eb.ref.allExcluded()))
// or
doUpdateSet((eb) => eb('excluded'))

import type { Countries } from '../types/index.js'; // kysely-codegen
type Country = Insertable<Countries>;

const data = [{ id: 1, name: 'UK' },{ id: 2, name: 'France' }];

const countries = data.map<Country>(country => ({
    id: country.id,
    name: country.name
}));

// proceed to do database stuff with "countries"

type Database = {
  a: {
     a1: string
     a2: number
  },
  b: {
     b1: string
     b2: number
  }
}
const Database = {
  a: {
     a1: true,
     a2: true
  },
  b: {
     b1: true,
     b2: true
  }
}

/** Generated by ts-morph script do not edit. */

import type { DB } from './index.js';

export type DBDummy<T = DB> = {
  readonly [K in keyof T]: ReadonlyArray<keyof T[K]>;
}

export const dbDummy: DBDummy = {
  countries: [
    'id',
    'name'
  ],
}

// db.ts
export interface Countries {
  id: number;
  name: string;
}
export interface DB {
  countries: Countries;
}

// db-runtime.ts
import type { DB } from './db.js';

type DBDummy = {
  readonly [K in keyof DB]: ReadonlyArray<keyof DB[K]>;
}
export const dbDummy: DBDummy = {
  countries: [
    'id',
    'name'
  ]
}

// kysely.ts
import type { OnConflictDatabase, OnConflictTables, StringReference, ExpressionBuilder, UpdateObject } from 'kysely';
import type { DB as PGDB } from '../types/db.js';
import { dbDummy } from '../types/db-runtime.js';

export function updateAllSet<DB extends PGDB, TB extends keyof DB & keyof PGDB>(table: TB) {
    return dbDummy[table].reduce<UpdateObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>>((acc, column) => {
        return {
            ...acc,
            [column]: (eb: ExpressionBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>) =>
                eb.ref(`excluded.${column as string}` as StringReference<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>)
        };
    }, {});
}

import { db } from '../util/db.js';
import { updateAllSet } from '../util/kysely.js';

const countries = [{ id: 1, name: 'a' }, { id: 2, name: 'b' }];

await db.insertInto('countries').values(countries)
    .onConflict(oc => oc
        .column('id')
        .doUpdateSet(
            updateAllSet('countries') // here you get type safety and can only select "countries"
        ))
    .execute();