packages/pass/types/protobuf/index.ts

   1 /*
   2  * We use a slightly altered data model than what protobuf would produce
   3  * internally, because the generics and polymorphism are easier to work with
   4  * this way, or better said, protobuf doesn't produce very easy-to-consume
   5  * types.
   6  */
   7 import type { ExtraField, ExtraIdentitySection, PlatformSpecific } from './item-v1';
   8 import {
   9     Content,
  10     Metadata,
  11     Item as ProtobufItem,
  12     ItemAlias as ProtobufItemAlias,
  13     ItemCreditCard as ProtobufItemCreditCard,
  14     ItemIdentity as ProtobufItemIdentity,
  15     ItemLogin as ProtobufItemLogin,
  16     ItemNote as ProtobufItemNote,
  17 } from './item-v1';
  18 import { Vault } from './vault-v1';
  19
  20 export {
  21     Content,
  22     ExtraField,
  23     ExtraIdentitySection,
  24     Metadata,
  25     ProtobufItem,
  26     ProtobufItemAlias,
  27     ProtobufItemCreditCard,
  28     ProtobufItemIdentity,
  29     ProtobufItemLogin,
  30     ProtobufItemNote,
  31     Vault,
  32 };
  33
  34 /**
  35  * Excludes the undefined oneofKind type generated by protoc-gen-ts
  36  * in ProtobufItem['content']
  37  */
  38 type OneOfKindKeys<T extends { content: any }> = Extract<T['content'], { oneofKind: string }>;
  39 type OneOfKindMap<U extends { oneofKind: string }> = {
  40     [T in U as T['oneofKind']]: Omit<T, 'oneofKind'> extends infer ContentType ? ContentType[keyof ContentType] : never;
  41 };
  42
  43 /**
  44  * Intermediary utility type that will flatten the union type resulting
  45  * from SafeProtobufItemContent to a single mapped object type containing
  46  * all possible key/type pairs for the underlying content types
  47  */
  48 type ItemContentUnion = OneOfKindKeys<Content>;
  49 export type ItemContentMap = OneOfKindMap<ItemContentUnion>;
  50 export type ItemType = keyof ItemContentMap;
  51
  52 type ExtraFieldContentUnion = OneOfKindKeys<ExtraField>;
  53 export type ExtraFieldContentMap = OneOfKindMap<ExtraFieldContentUnion>;
  54 export type ExtraFieldType = keyof ExtraFieldContentMap;
  55
  56 /**
  57  * Creates a generic "distributive object type" over all possible
  58  * oneofKind keys - When decoding protobuf items, this will allow us
  59  * to select the underlying content type by its oneofKind property
  60  * while maintaining strong type safety
  61  */
  62 export type SafeProtobufItem<T extends ItemType = ItemType> = {
  63     content: {
  64         content: {
  65             [Key in T]: {
  66                 oneofKind: Key;
  67             } & { [ItemKey in Key]: ItemContentMap[Key] };
  68         }[T];
  69     };
  70     metadata: Metadata;
  71     extraFields: SafeProtobufExtraField[];
  72     platformSpecific?: PlatformSpecific;
  73 };
  74
  75 export type SafeProtobufExtraField<T extends ExtraFieldType = ExtraFieldType> = { fieldName: string } & {
  76     [Key in T]: {
  77         content: { oneofKind: Key } & {
  78             [ExtraFieldKey in Key]: ExtraFieldContentMap[Key];
  79         };
  80     };
  81 }[T];