TypeScript - extract interface members only - possible?

Since typescript interfaces don't exist at runtime, we can't use them to guide any runtime behavior, just compile-time type checking. We can however create an object that has the same properties as the interface (with all the properties of type true for example to simplify initialization) and make the compiler trigger an error if this object has any more or less fields then the interface. We can use this object as the guide to what properties we extract:

function extract<T>(properties: Record<keyof T, true>){
    return function<TActual extends T>(value: TActual){
        let result = {} as T;
        for (const property of Object.keys(properties) as Array<keyof T>) {
            result[property] = value[property];
        }
        return result;
    }
}

interface ISpecific { A: string; B: string; }
const extractISpecific = extract<ISpecific>({ 
    // This object literal is guaranteed by the compiler to have no more and no less properties then ISpecific
    A: true,
    B: true
})
class Extended implements ISpecific { public A: string = '1'; public B: string = '2'; public C: string = '3'; }

let someObject = new Extended(); 
let subset = extractISpecific(someObject); 

If you want to limit the types you use you can do it simply and safely with:

let subset = someObject as ISpecific; 

The properties will still exist on subset but the compiler will prevent you depending on them, i.e. subset.age will fail below, although the property does still exist.

interface ISpecific {
    name: string;
}

const someObject = {
    name: 'Fenton',
    age: 21
};

let subset = someObject as ISpecific; 

console.log(subset.age);

You could really ditch the properties by destructuring like this, the danger being that you need to include "all the things I don't want" in the list before ...subset.

interface ISpecific {
    name: string;
}

const someObject = {
    name: 'Fenton',
    age: 21
};

let { age, ...subset } = someObject;   

console.log(JSON.stringify(someObject));
console.log(JSON.stringify(subset));

Another easy option I came across is using lodash's pick function. It's a bit tedious, but does the job pretty well.

First, define a class that represents your interface. You will need it later to easily create an object of that class.

class Specific {
  constructor(readonly a?: string, readonly b?: string) {}
}
interface ISpecific extends Specific {}
interface IExtended extends ISpecific {
  c: string;
}

Then let's say that this is the original object you want to extract data from:

const extended: IExtended = { a: 'type', b: 'script', c: 'is cool' };

Now comes the fun part. Get a list of Specific keys based on a new instantiation of the class, and pick those members from the original object.
In other words:

const specificMembers: string[] = Object.keys(new Specific());
const specific: ISpecific = lodash.pick(extended, specificMembers);
console.log(specific); // {a: "type", b: "script"}

Voilà! :)

@titian is correct that typescript interfaces/types don't exist at runtime, but the executable code DOES exist at compile-time!

If you don't need a class, here's a much shorter, much less-to-type solution that takes a type or instance and a simple array of strings as keys:

  const pickSafely = <ObjectType>(keys: readonly `${string & keyof ObjectType}`[]) => {
    return (object: any) => {
      const resultObject: ObjectType = {} as unknown as ObjectType;
      for (let index = 0; index < keys.length; index += 1) {
        const key = keys[index] as unknown as keyof ObjectType;
        resultObject[key] = object[key];
      }

      return resultObject as ObjectType;
    }
  }

This approach will save you keystrokes when it's time to use it:

  // Imagine this came from your database.
  const user = {
    firstName: 'Bill',
    favouriteColor: 'green',
    creditCard: 'what is this doing here?',
  };

  // Imagine this is your model.
  type User = {
    firstName?: string;
    favouriteColor?: string;
  }
  const userKeys = ['firstName', 'favouriteColor'] as const;
  const pickUser = pickSafely<User>(userKeys); // No type error.

  // And here's your application usage.
  const safeUser = pickUser(user);

But more importantly, it protects you from picking a key that is NOT allowed by the type. This is useful if you want to use pickSafely to sanitize data coming from a user or strip out fields from a database responses before sending them over the wire.

  // Imagine this came from your database.
  const user = {
    firstName: 'Bill',
    favouriteColor: 'green',
    creditCard: 'what is this doing here?',
  };

  // Imagine this is your model.
  type User = {
    firstName?: string;
    favouriteColor?: string;
  }
  const userKeysWhoopsie = ['firstName', 'favouriteColor', 'creditCard'] as const;
  const pickUserUhOh = pickSafely<User>(userKeysWhoopsie); // Shows a type error - hmm, picking a property you shouldn't?

  // In your application
  const pwndUser = pickUser(user); // This won't execute, it won't compile.

The magic bit of this solution is using Template Literal Types to dynamically generate a union of literal types from a normal Type.

This does NOT protect you from adding a property to ObjectType and forgetting to add it to keys - think of it as a whitelist that is itself whitelisted by the type ;)

Here's the type error this code produces in VSCode:

You can solve this in a clean way using the Zod library:

import { z } from "zod";

export const ISPECIFIC_SCHEMA = z.object({
    A: z.string(),
    B: z.string(),
});
export type ISpecific = z.infer<typeof ISPECIFIC_SCHEMA>;

const someObject = { A: "a", B: "b", C: "c" };
const subset = ISPECIFIC_SCHEMA.parse(someObject);
console.log(subset); // { A: 'a', B: 'b' }

This works, because Zod preserves type information (ISPECIFIC_SCHEMA) at runtime.

With this solution, you only need to specify the type once.

unfortunately not, you need especify and repeat the parts.

export interface Machine {
  id: string;
  name: string;
  logo: string;
  location: Location;
  products: Item[];
  restriction: string;
  categories: string[];
  star: number;
  distance: number;
}

export interface MachineIdentification {
  id: string;
  name: string;
  logo: string;
  location: Location;
}

//Object Destructuring fat object in parts
const {id, name, logo, location} = machine; 

//Compose a ligth object from parts and apply interface type
const mi: MachineIdentification = {id, name, logo, location};