Auto generate shorthand types for certain configuration settings.

[Atlinx]

Right now it's really hard to decouple setting creation from EntityManager creation. This is because all the setting types in EntityManager are buried within layers of nested generics. In order to decouple code whilst maintaining typing + autocomplete, we have to dig into the internals of Typettta to find the right type. This means our code is now coupled to the implementation of the code generation.

In terms of what settings to expose as simplified types, I think scalars, security, and security.policies should be given their own types.

WITHOUT SUGGESTION

new EntityManager<...>(
{
  ...
  scalars: getScalarSettings(); // scalars uses the custom generated ScalarSettings type
  security: getSecuritySettings(); // security uses the custom generated SecuritySettings type
  ...
}
);

// Very long name + nested generics
function getScalarSetting(): UserInputDriverDataTypeAdapterMap<Scalars, "mongo"> {
  return { ... }
}

// I have no idea what to return for this because of how nested and complex it is
function getSecuritySettings():  ________ {
  return {
    policies: getSecurityPolicies() 
    ...
  }
}

// I have no idea what to return for this because of how nested and complex it is
function getSecurityPolicies(): ________ {
  return { ... }
}

WITH SUGGESTION

new EntityManager<...>(
{
  ...
  scalars: getScalarSettings(); // scalars uses the custom generated EntityManager<...>.ScalarSettings type
  security: getSecuritySettings(); // security uses the custom generated EntityManager<...>.SecuritySettings type
  ...
}
);

function getScalarSettings(): EntityManager<...>.ScalarSettings {
  return { ... }
}

function getSecuritySettings():  EntityManager<...>.SecuritySettings {
  return {
    policies: getSecurityPolicies() 
    ...
  }
}

function getSecurityPolicies(): EntityManager<...>.SecuritySettings.Policies {
  return { ... }
}

[edobrb]

I like the idea, i'll open an issue to keep track of the progression.

[edobrb]

I was thinking to generate a type like this:

export type EntityManagerTypes<MetadataType = never, OperationMetadataType = never, Permissions extends string = never, SecurityDomain extends object = never> = {
  entityManager: EntityManager<MetadataType, OperationMetadataType, Permissions, SecurityDomain>
  params: {
    metadata: MetadataType
    middleware: EntityManagerMiddleware<MetadataType, OperationMetadataType>
    groupMiddleware: GroupMiddleware<any, MetadataType, OperationMetadataType>
    overrides: {
      hotel: Pick<Partial<HotelDAOParams<MetadataType, OperationMetadataType>>, 'idGenerator' | 'middlewares' | 'metadata'>
      reservation: Pick<Partial<ReservationDAOParams<MetadataType, OperationMetadataType>>, 'idGenerator' | 'middlewares' | 'metadata'>
      role: Pick<Partial<RoleDAOParams<MetadataType, OperationMetadataType>>, 'middlewares' | 'metadata'>
      room: Pick<Partial<RoomDAOParams<MetadataType, OperationMetadataType>>, 'idGenerator' | 'middlewares' | 'metadata'>
      user: Pick<Partial<UserDAOParams<MetadataType, OperationMetadataType>>, 'idGenerator' | 'middlewares' | 'metadata'>
      userRole: Pick<Partial<UserRoleDAOParams<MetadataType, OperationMetadataType>>, 'middlewares' | 'metadata'>
    }
    mongodb: Record<'default', M.Db | 'mock'>
    scalars: T.UserInputDriverDataTypeAdapterMap<types.Scalars, 'mongo'>
    log: T.LogInput<'hotel' | 'reservation' | 'role' | 'room' | 'user' | 'userRole'>
    security: T.EntityManagerSecurtyPolicy<DAOGenericsMap<MetadataType, OperationMetadataType>, OperationMetadataType, Permissions, SecurityDomain>
  }
  security: {
   context: T.DAOSecurityContext<SecurityDomain, Permissions>
   policies: T.DAOSecurityPolicies<DAOGenericsMap<MetadataType, OperationMetadataType>, Permissions, SecurityDomain>
   permissions: Permissions
   domain: SecurityDomain
  }
}

I'd like to generate an all-encompassing type so that whatever type you need is there. Maybe I could add all the various DAOs too. In your cases you can do something like this:

type EMT = EntityManagerTypes<...>
function getScalarSettings(): EMT['params']['scalars'] {
  return { ... }
}

function getSecuritySettings():  EMT['params']['security'] {
  return {
    policies: getSecurityPolicies() 
    ...
  }
}

function getSecurityPolicies(): EMT['security']['policies'] {
  return { ... }
}

What do you think? @Atlinx @minox86

[Atlinx]

Looks good! This provides autocomplete for intellisense right, even though it uses strings?

[edobrb]

Yes, intellisense works well