似ているオブジェクト間の変換処理方法について

Question

以下のコードのように大部分のプロパティが同じで一部のみ異なるオブジェクト間で
変換処理を行いたいと考えております。

interface Base {
    a: number
    b: string
    dontUse: string
}

interface Convert {
    a: number
    b: string
    c: string
}


let base: Base = {
    a: 1,
    b: '2',
    dontUse: 'DontUse'
}

delete base.dontUse;

let convert: Convert { // <-- error発生箇所
    ...base,            
    c: 'sample',
} 

console.log(convert);

上記コードは変換したjsは想定通りに動きますがTypeScriptとしては以下のようなエラーが出ます。

Type '{ c: string; a: number; b: string; dontUse: string; }' is not assignable to type 'Convert'.
  Object literal may only specify known properties, and 'dontUse' does not exist in type 'Convert'.

今回は簡易版ですが、a,bのようなメンバが大量にあるのでできるだけ上記のような書き方をしたいのですが
良い方法はないでしょうか？

型キャストで無理矢理な変換ですとBaseやConvertに変更があった場合に、コンパイルエラーにならないため
それは避けたいと考えています。

イメージですが以下のようなコードが書けると一番嬉しいんです。

interface Base {
    a: number
    b: string
    dontUse: string
}

type Convert = {
    [P in keyof Base]: Base[P]; // want to delete from keyof Base 'dontUse' and add 'c'
    c: string;
    dontUse: undefined;
}



let base: Base = {
    a: 1,
    b: '2',
    dontUse: 'DontUse'
}

delete base.dontUse;

let convert: Convert = {
    ...base,
    c: 'sample',
} 

console.log(convert);

keyof でBaseのプロパティが取れるので、それに対してcを追加し dontUseを削除できれば一番綺麗だと思われます。

尚サンプルコードはこちらにおいています

Answer 1

function toConvert({ a, b }: { a: number, b: string }) {
    return { ...{ a, b }, c: 'sample' };
}

こういう関数ではいかがですか？

Comments

[m0a]

a,bのメンバが多数ある場合はしんどいので今回は使えなさそうです。ありがとうございました

Answer 2

サンプルのケースではas Convertと型アサーションを使うとコンパイルエラーは無くなります。

let convert: Convert = {
  ...base,
  c: 'sample',
} as Convert;

(追記)Base型をベースにConvert型を定義する

TypeScriptでDiff型を表現する - Qiitaを参考に不要なプロパティを除いて継承してみました。共通部分のクラスを定義して継承した方がわかりやすそうな気がしますが。

type DiffKey<T extends string, U extends string> = (
    & {[P in T]: P }
    & {[P in U]: never }
    & { [x: string]: never }
)[T];

type Omit<T, K extends keyof T> = Pick<T, DiffKey<keyof T, K>>;

interface Base {
    a: number;
    b: string;
    dontUse: string;
    dontUse2: string;
}

interface Convert extends Omit<Base, 'dontUse' | 'dontUse2'> {
    c: string;
}

let convert: Convert = {
    a: 1,
    b: '2',
    c: 'sample',
};
console.log(convert); // { a: 1, b: '2', c: 'sample' }
convert.dontUse = 'dontUse'; // compile error: 'dontUse' does not exist in type 'Convert'

Comments

[m0a]

それですと、更にbaseに更に変更があった場合TypeScript側で検知できなくなりますよね。コンパイルエラー自体は必要なので、型キャスト以外の方法を探しています。

[m0a]

簡単というワードが紛らわしかったかもしれません。追加情報を入れました。

[m0a]

予想より複雑でしたが、上手くいきそうです。ありがとうございました。