@sphereon/ssi-sdk.data-store 0.34.1-next.91 → 0.36.0

package/src/types/contact/contact.ts

@@ -1,295 +0,0 @@
-import { ManagedIdentifierOptsOrResult } from '@sphereon/ssi-sdk-ext.identifier-resolution'
-import { IIdentifier } from '@veramo/core'
-import { IIssuerLocaleBranding } from '../issuanceBranding/issuanceBranding'
-import { CredentialRole } from '../digitalCredential'
-
-export type MetadataTypes = string | number | Date | boolean | undefined
-
-export interface IMetadataEntity {
-  // TODO move to types
-  label: string
-  stringValue?: string
-  numberValue?: number
-  dateValue?: Date
-  boolValue?: boolean
-}
-
-export type Party = {
-  id: string
-  uri?: string
-  roles: Array<CredentialRole>
-  ownerId?: string
-  tenantId?: string
-  identities: Array<Identity>
-  electronicAddresses: Array<ElectronicAddress>
-  physicalAddresses: Array<PhysicalAddress>
-  contact: Contact
-  partyType: PartyType
-  /**
-   * TODO: Integrate branding logic here in the future. What we should do is make the issuance branding plugin part of the contact-manager and retrieve any branding there is.
-   *
-   * Currently, we are only defining the branding type within the SDK without implementing the associated logic. This is because:
-   * 1. We are combining two types from the SSI-SDK to create a new type that will be used across multiple places in the wallets (web & mobile).
-   * 2. While it makes sense to have this combined type in the SDK, the logic to support database connections for these types is complex. The types belong to different modules, and we don't use them together currently.
-   * 3. Implementing the full logic now would require significant changes and cross-module interactions, which we don't have the time to address at present.
-   *
-   * For now, we are defining the type here and will use it in the mobile wallet has the logic for it. This is a temporary solution until we have the resources to integrate the branding logic fully.
-   */
-  branding?: IIssuerLocaleBranding
-  relationships: Array<PartyRelationship>
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-export type NonPersistedParty = Omit<
-  Party,
-  | 'id'
-  | 'identities'
-  | 'electronicAddresses'
-  | 'physicalAddresses'
-  | 'contact'
-  | 'roles'
-  | 'partyType'
-  | 'relationships'
-  | 'createdAt'
-  | 'lastUpdatedAt'
-> & {
-  identities?: Array<NonPersistedIdentity>
-  electronicAddresses?: Array<NonPersistedElectronicAddress>
-  physicalAddresses?: Array<NonPersistedPhysicalAddress>
-  contact: NonPersistedContact
-  partyType: NonPersistedPartyType
-  relationships?: Array<NonPersistedPartyRelationship>
-}
-export type PartialParty = Partial<
-  Omit<Party, 'identities' | 'electronicAddresses' | 'physicalAddresses' | 'contact' | 'partyType' | 'relationships'>
-> & {
-  identities?: PartialIdentity
-  electronicAddresses?: PartialElectronicAddress
-  physicalAddresses?: PartialPhysicalAddress
-  contact?: PartialContact
-  partyType?: PartialPartyType
-  relationships?: PartialPartyRelationship
-}
-
-export type Identity = {
-  id: string
-  alias: string
-  ownerId?: string
-  tenantId?: string
-  origin: IdentityOrigin
-  roles: Array<CredentialRole>
-  identifier: CorrelationIdentifier
-  connection?: Connection
-  metadata?: Array<MetadataItem<MetadataTypes>>
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-export type NonPersistedIdentity = Omit<Identity, 'id' | 'identifier' | 'connection' | 'metadata' | 'origin' | 'createdAt' | 'lastUpdatedAt'> & {
-  origin: IdentityOrigin
-  identifier: NonPersistedCorrelationIdentifier
-  connection?: NonPersistedConnection
-  metadata?: Array<NonPersistedMetadataItem<MetadataTypes>>
-}
-export type PartialIdentity = Partial<Omit<Identity, 'identifier' | 'connection' | 'metadata' | 'origin' | 'roles'>> & {
-  identifier?: PartialCorrelationIdentifier
-  connection?: PartialConnection
-  metadata?: PartialMetadataItem<MetadataTypes> // Usage: FindIdentityArgs = Array<PartialIdentity>
-  origin?: IdentityOrigin
-  roles?: CredentialRole
-  partyId?: string
-}
-
-export type MetadataItem<T extends MetadataTypes> = {
-  id: string
-  label: string
-  value: T
-}
-
-export type NonPersistedMetadataItem<T extends MetadataTypes> = Omit<MetadataItem<T>, 'id'>
-export type PartialMetadataItem<T extends MetadataTypes> = Partial<MetadataItem<T>>
-
-export type CorrelationIdentifier = {
-  id: string
-  ownerId?: string
-  tenantId?: string
-  type: CorrelationIdentifierType
-  correlationId: string
-}
-export type NonPersistedCorrelationIdentifier = Omit<CorrelationIdentifier, 'id'>
-export type PartialCorrelationIdentifier = Partial<CorrelationIdentifier>
-
-export type Connection = {
-  id: string
-  ownerId?: string
-  tenantId?: string
-  type: ConnectionType
-  config: ConnectionConfig
-}
-export type NonPersistedConnection = Omit<Connection, 'id' | 'config'> & {
-  config: NonPersistedConnectionConfig
-}
-export type PartialConnection = Partial<Omit<Connection, 'config'>> & {
-  config: PartialConnectionConfig
-}
-
-export type OpenIdConfig = {
-  id: string
-  clientId: string
-  clientSecret: string
-  ownerId?: string
-  tenantId?: string
-  scopes: Array<string>
-  issuer: string
-  redirectUrl: string
-  dangerouslyAllowInsecureHttpRequests: boolean
-  clientAuthMethod: 'basic' | 'post' | undefined
-}
-export type NonPersistedOpenIdConfig = Omit<OpenIdConfig, 'id'>
-export type PartialOpenIdConfig = Partial<OpenIdConfig>
-
-export type DidAuthConfig = {
-  id: string
-  idOpts: ManagedIdentifierOptsOrResult
-  stateId: string
-  ownerId?: string
-  tenantId?: string
-  redirectUrl: string
-  sessionId: string
-}
-export type NonPersistedDidAuthConfig = Omit<DidAuthConfig, 'id'>
-export type PartialDidAuthConfig = Partial<Omit<DidAuthConfig, 'identifier'>> & {
-  identifier: Partial<IIdentifier> // TODO, we need to create partials for sub types in IIdentifier
-}
-
-export type ConnectionConfig = OpenIdConfig | DidAuthConfig
-export type NonPersistedConnectionConfig = NonPersistedDidAuthConfig | NonPersistedOpenIdConfig
-export type PartialConnectionConfig = PartialOpenIdConfig | PartialDidAuthConfig
-
-export type NaturalPerson = {
-  id: string
-  firstName: string
-  lastName: string
-  middleName?: string
-  displayName: string
-  metadata?: Array<MetadataItem<MetadataTypes>>
-  ownerId?: string
-  tenantId?: string
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-
-export type NonPersistedNaturalPerson = Omit<NaturalPerson, 'id' | 'createdAt' | 'lastUpdatedAt'>
-
-export type PartialNaturalPerson = Partial<Omit<NaturalPerson, 'metadata'>> & {
-  metadata?: PartialMetadataItem<MetadataTypes>
-}
-
-export type Organization = {
-  id: string
-  legalName: string
-  displayName: string
-  metadata?: Array<MetadataItem<MetadataTypes>>
-  ownerId?: string
-  tenantId?: string
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-export type NonPersistedOrganization = Omit<Organization, 'id' | 'createdAt' | 'lastUpdatedAt'>
-export type PartialOrganization = Partial<Omit<Organization, 'metadata'>> & {
-  metadata?: PartialMetadataItem<MetadataTypes>
-}
-
-export type Contact = NaturalPerson | Organization
-export type NonPersistedContact = NonPersistedNaturalPerson | NonPersistedOrganization
-export type PartialContact = PartialNaturalPerson | PartialOrganization
-
-export type PartyType = {
-  id: string
-  type: PartyTypeType
-  origin: PartyOrigin
-  name: string
-  tenantId: string
-  description?: string
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-export type NonPersistedPartyType = Omit<PartyType, 'id' | 'createdAt' | 'lastUpdatedAt'> & {
-  id?: string
-}
-export type PartialPartyType = Partial<PartyType>
-
-export type PartyRelationship = {
-  id: string
-  leftId: string
-  rightId: string
-  ownerId?: string
-  tenantId?: string
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-export type NonPersistedPartyRelationship = Omit<PartyRelationship, 'id' | 'createdAt' | 'lastUpdatedAt'>
-export type PartialPartyRelationship = Partial<PartyRelationship>
-
-export type ElectronicAddress = {
-  id: string
-  type: ElectronicAddressType
-  electronicAddress: string
-  ownerId?: string
-  tenantId?: string
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-export type NonPersistedElectronicAddress = Omit<ElectronicAddress, 'id' | 'createdAt' | 'lastUpdatedAt'>
-export type PartialElectronicAddress = Partial<ElectronicAddress> & {
-  partyId?: string
-}
-
-export type PhysicalAddress = {
-  id: string
-  type: PhysicalAddressType
-  streetName: string
-  streetNumber: string
-  postalCode: string
-  cityName: string
-  provinceName: string
-  countryCode: string
-  buildingName?: string
-  ownerId?: string
-  tenantId?: string
-  createdAt: Date
-  lastUpdatedAt: Date
-}
-export type NonPersistedPhysicalAddress = Omit<PhysicalAddress, 'id' | 'createdAt' | 'lastUpdatedAt'>
-export type PartialPhysicalAddress = Partial<PhysicalAddress> & {
-  partyId?: string
-}
-
-export type ElectronicAddressType = 'email' | 'phone'
-
-export type PhysicalAddressType = 'home' | 'visit' | 'postal'
-
-export enum ConnectionType {
-  OPENID_CONNECT = 'OIDC',
-  SIOPv2 = 'SIOPv2',
-  SIOPv2_OpenID4VP = 'SIOPv2+OpenID4VP',
-}
-
-export enum CorrelationIdentifierType {
-  DID = 'did',
-  URL = 'url',
-}
-
-export enum PartyTypeType {
-  NATURAL_PERSON = 'naturalPerson',
-  ORGANIZATION = 'organization',
-}
-
-export enum PartyOrigin {
-  INTERNAL = 'INTERNAL',
-  EXTERNAL = 'EXTERNAL',
-}
-
-export enum IdentityOrigin {
-  INTERNAL = 'INTERNAL',
-  EXTERNAL = 'EXTERNAL',
-}

package/src/types/contact/index.ts

@@ -1,2 +0,0 @@
-export * from './contact'
-export * from './IAbstractContactStore'

package/src/types/digitalCredential/IAbstractDigitalCredentialStore.ts

@@ -1,43 +0,0 @@
-import { HasherSync } from '@sphereon/ssi-types'
-import { FindOptionsOrder } from 'typeorm'
-import { DigitalCredentialEntity } from '../../entities/digitalCredential/DigitalCredentialEntity'
-import { DigitalCredential } from './types'
-import { CredentialCorrelationType, CredentialRole, CredentialStateType, RegulationType } from './enums'
-
-export type GetCredentialArgs = { id: string } | { hash: string }
-
-export type FindDigitalCredentialArgs = Array<Partial<DigitalCredential>>
-
-export type GetCredentialsArgs = {
-  filter?: FindDigitalCredentialArgs
-  offset?: number
-  limit?: number
-  order?: string | FindOptionsOrder<DigitalCredentialEntity>
-}
-
-export type GetCredentialsResponse = {
-  data: Array<DigitalCredential>
-  total: number
-}
-
-export type AddCredentialArgs = {
-  rawDocument: string
-  kmsKeyRef?: string
-  identifierMethod?: string
-  regulationType?: RegulationType
-  parentId?: string
-  issuerCorrelationType: CredentialCorrelationType
-  subjectCorrelationType?: CredentialCorrelationType
-  issuerCorrelationId: string
-  subjectCorrelationId?: string
-  credentialRole: CredentialRole
-  tenantId?: string
-  state?: CredentialStateType
-  verifiedAt?: Date
-  revokedAt?: Date
-  opts?: { maxTimeSkewInMS?: number; hasher?: HasherSync }
-}
-
-export type UpdateCredentialStateArgs = GetCredentialArgs & { verifiedState: CredentialStateType; verifiedAt?: Date; revokedAt?: Date }
-
-export type RemoveCredentialArgs = GetCredentialArgs

package/src/types/digitalCredential/enums.ts

@@ -1,70 +0,0 @@
-export enum DocumentType {
-  VC = 'VC',
-  VP = 'VP',
-  P = 'P',
-  C = 'C',
-}
-
-export enum RegulationType {
-  PID = 'PID',
-  QEAA = 'QEAA',
-  EAA = 'EAA',
-  NON_REGULATED = 'NON_REGULATED',
-}
-
-export enum CredentialDocumentFormat {
-  JSON_LD = 'JSON_LD',
-  JWT = 'JWT',
-  SD_JWT = 'SD_JWT',
-  MSO_MDOC = 'MSO_MDOC',
-}
-
-export namespace CredentialDocumentFormat {
-  export function fromSpecValue(credentialFormat: string) {
-    const format = credentialFormat.toLowerCase()
-    if (format.includes('sd')) {
-      return CredentialDocumentFormat.SD_JWT
-    } else if (format.includes('ldp')) {
-      return CredentialDocumentFormat.JSON_LD
-    } else if (format.includes('mso') || credentialFormat.includes('mdoc')) {
-      return CredentialDocumentFormat.MSO_MDOC
-    } else if (format.includes('jwt_')) {
-      return CredentialDocumentFormat.JWT
-    } else {
-      throw Error(`Could not map format ${format} to known format`)
-    }
-  }
-
-  export function toSpecValue(documentFormat: CredentialDocumentFormat, documentType: DocumentType) {
-    switch (documentFormat) {
-      case CredentialDocumentFormat.SD_JWT:
-        return 'dc+sd-jwt'
-      case CredentialDocumentFormat.MSO_MDOC:
-        return 'mso_mdoc'
-      case CredentialDocumentFormat.JSON_LD:
-        return documentType === DocumentType.C || documentType === DocumentType.VC ? 'ldp_vc' : 'ldp_vp'
-      case CredentialDocumentFormat.JWT:
-        return documentType === DocumentType.C || documentType === DocumentType.VC ? 'jwt_vc_json' : 'jwt_vp_json'
-    }
-  }
-}
-
-export enum CredentialCorrelationType {
-  DID = 'DID',
-  X509_SAN = 'X509_SAN',
-  KID = 'KID',
-  URL = 'URL',
-}
-
-export enum CredentialRole {
-  ISSUER = 'ISSUER',
-  VERIFIER = 'VERIFIER',
-  HOLDER = 'HOLDER',
-  FEDERATION_TRUST_ANCHOR = 'FEDERATION_TRUST_ANCHOR',
-}
-
-export enum CredentialStateType {
-  REVOKED = 'REVOKED',
-  VERIFIED = 'VERIFIED',
-  EXPIRED = 'EXPIRED',
-}

package/src/types/digitalCredential/index.ts

@@ -1,3 +0,0 @@
-export type * from './types'
-export * from './enums'
-export * from './IAbstractDigitalCredentialStore'

package/src/types/digitalCredential/types.ts

@@ -1,39 +0,0 @@
-import { CredentialCorrelationType, CredentialDocumentFormat, CredentialRole, CredentialStateType, DocumentType, RegulationType } from './enums'
-
-/**
- * DigitalCredential
- *
- * @public
- */
-export type DigitalCredential = {
-  id: string
-  parentId?: string
-  documentType: DocumentType
-  documentFormat: CredentialDocumentFormat
-  credentialRole: CredentialRole
-  regulationType: RegulationType
-  rawDocument: string
-  uniformDocument: string
-  credentialId?: string
-  hash: string
-  kmsKeyRef?: string
-  identifierMethod?: string
-  issuerCorrelationType: CredentialCorrelationType
-  subjectCorrelationType?: CredentialCorrelationType
-  rpCorrelationType?: CredentialCorrelationType
-  isIssuerSigned?: boolean
-  issuerCorrelationId: string
-  subjectCorrelationId?: string
-  rpCorrelationId?: string
-  verifiedState?: CredentialStateType
-  tenantId?: string
-  createdAt: Date
-  presentedAt?: Date
-  lastUpdatedAt: Date
-  validUntil?: Date
-  validFrom?: Date
-  verifiedAt?: Date
-  revokedAt?: Date
-}
-
-export type NonPersistedDigitalCredential = Omit<DigitalCredential, 'id' | 'regulationType'> & { regulationType?: RegulationType }

package/src/types/eventLogger/IAbstractEventLoggerStore.ts

@@ -1,22 +0,0 @@
-import { PartialActivityLoggingEvent, PartialAuditLoggingEvent } from '@sphereon/ssi-sdk.core'
-import { NonPersistedActivityLoggingEvent, NonPersistedAuditLoggingEvent } from './eventLogger'
-
-export type FindAuditLoggingEventArgs = Array<PartialAuditLoggingEvent>
-
-export type FindActivityLoggingEventArgs = Array<PartialActivityLoggingEvent>
-
-export type StoreAuditEventArgs = {
-  event: NonPersistedAuditLoggingEvent
-}
-
-export type StoreActivityEventArgs = {
-  event: NonPersistedActivityLoggingEvent
-}
-
-export type GetAuditEventsArgs = {
-  filter?: FindAuditLoggingEventArgs
-}
-
-export type GetActivityEventsArgs = {
-  filter?: FindActivityLoggingEventArgs
-}

package/src/types/eventLogger/eventLogger.ts

@@ -1,4 +0,0 @@
-import { ActivityLoggingEvent, AuditLoggingEvent } from '@sphereon/ssi-sdk.core'
-
-export type NonPersistedAuditLoggingEvent = Omit<AuditLoggingEvent, 'id' | 'type'>
-export type NonPersistedActivityLoggingEvent = Omit<ActivityLoggingEvent, 'id' | 'type'>

package/src/types/issuanceBranding/IAbstractIssuanceBrandingStore.ts

@@ -1,85 +0,0 @@
-import {
-  IBasicCredentialLocaleBranding,
-  IBasicIssuerLocaleBranding,
-  ICredentialBranding,
-  ICredentialLocaleBrandingFilter,
-  IIssuerBranding,
-  IIssuerBrandingFilter,
-  IIssuerLocaleBrandingFilter,
-  ILocaleBranding,
-  ICredentialBrandingFilter,
-} from './issuanceBranding'
-
-export type FindCredentialBrandingArgs = Array<ICredentialBrandingFilter>
-export type FindCredentialLocaleBrandingArgs = Array<ICredentialLocaleBrandingFilter>
-export type FindIssuerBrandingArgs = Array<IIssuerBrandingFilter>
-export type FindIssuerLocaleBrandingArgs = Array<IIssuerLocaleBrandingFilter>
-
-export interface IAddCredentialBrandingArgs {
-  vcHash: string
-  issuerCorrelationId: string
-  localeBranding: Array<IBasicCredentialLocaleBranding>
-}
-
-export interface IGetCredentialBrandingArgs {
-  filter?: FindCredentialBrandingArgs
-}
-
-export interface IUpdateCredentialBrandingArgs {
-  credentialBranding: Omit<ICredentialBranding, 'localeBranding' | 'createdAt' | 'lastUpdatedAt'>
-}
-
-export interface IRemoveCredentialBrandingArgs {
-  filter: FindCredentialBrandingArgs
-}
-
-export interface IAddCredentialLocaleBrandingArgs {
-  credentialBrandingId: string
-  localeBranding: Array<IBasicCredentialLocaleBranding>
-}
-
-export interface IUpdateCredentialLocaleBrandingArgs {
-  localeBranding: Omit<ILocaleBranding, 'createdAt' | 'lastUpdatedAt'>
-}
-
-export interface IRemoveCredentialLocaleBrandingArgs {
-  filter: FindCredentialLocaleBrandingArgs
-}
-
-export interface IGetCredentialLocaleBrandingArgs {
-  filter?: FindCredentialLocaleBrandingArgs
-}
-
-export interface IAddIssuerBrandingArgs {
-  issuerCorrelationId: string
-  localeBranding: Array<IBasicIssuerLocaleBranding>
-}
-
-export interface IGetIssuerBrandingArgs {
-  filter?: FindIssuerBrandingArgs
-}
-
-export interface IUpdateIssuerBrandingArgs {
-  issuerBranding: Omit<IIssuerBranding, 'localeBranding' | 'createdAt' | 'lastUpdatedAt'>
-}
-
-export interface IRemoveIssuerBrandingArgs {
-  filter: FindIssuerBrandingArgs
-}
-
-export interface IAddIssuerLocaleBrandingArgs {
-  issuerBrandingId: string
-  localeBranding: Array<IBasicIssuerLocaleBranding>
-}
-
-export interface IUpdateIssuerLocaleBrandingArgs {
-  localeBranding: Omit<ILocaleBranding, 'createdAt' | 'lastUpdatedAt'>
-}
-
-export interface IRemoveIssuerLocaleBrandingArgs {
-  filter: FindIssuerLocaleBrandingArgs
-}
-
-export interface IGetIssuerLocaleBrandingArgs {
-  filter?: FindIssuerLocaleBrandingArgs
-}