Looking back

The five tips

1. Using IDE to get the type of literals:

https://github.com/n1rjal/init.lua/

2. Making null safe

Copy
interface UserProfile {
  id: number;                  // required property
  name: string | null;          // can be string or null
  email?: string;               // optional property (can be undefined)
  phone?: string | null;        // optional and can be null
}

const user: UserProfile = {
  id: 1,
  name: null,                   // valid due to `string | null`
  // email is optional, so it's not provided
  phone: null                   // valid due to `string | null | undefined`
};


function printName(name:string){
    return name + "Hello"
}

Using this argument will not prevent any error. Incase if the value of phone is actually null

3. Getting parameters type for a method from library

Copy
// lets asssume that this interface is not exportted by the library
 // How can we get the same interface without using DatabaseConnectionParams
interface DatabaseConnectionParams{
  host:string,
  port: number,
  user: string,
  password: string,
}

function connectToDatabase(params:DatabaseConnectionParams){
  return `CONNECTED to ${params.host}:${params.port}`;
}

const connectionParams = {
  host:"localhost",
  port: 5432,
  user: "testuser",
  password:"test12345",
}

connectToDatabase(connectionParams);

You can also use ReturnType for to get the return value type

We can use types like [0] for type and [”methodName”] for accessing methods in a class

1. Parameters is used to get all the parameters of a function or method. It will return every type of parameters for each arguments of the function in tuple form.
2. typeof: typeof operator is used when we want to get the type of an typescript legal literal.
3. [0]: Here we used [0] to get the type of tuple parameters.

4. Not using Readonly, Pick, Omit, and Partial

1. readonly: The readonly utility type makes all properties of an object immutable, meaning they cannot be modified after the object is created.

Copy
type Person = {
  name: string;
  age: number;
};

const person: Readonly<Person> = {
  name: "John",
  age: 30,
};

person.age = 31; // Error: Cannot assign to 'age' because it is a read-only property.

1. omit: The Omit utility type creates a new type by removing one or more keys from an existing type.

Copy
type Person = {
  name: string;
  age: number;
  address: string;
};

type WithoutAddress = Omit<Person, 'address'>;
// This results in a type that has 'name' and 'age' but no 'address'

1. pick: The Pick utility type creates a new type by selecting a subset of properties from an existing type.

Copy
type Person = {
  name: string;
  age: number;
  address: string;
};

type NameAndAge = Pick<Person, 'name' | 'age'>;
// This results in a type that only has 'name' and 'age'

1. partial: The Partial utility type makes all properties of an object optional.

Copy
type Person = {
  name: string;
  age: number;
  address: string;
};

const partialPerson: Partial<Person> = {
  name: "John",
};
// 'age' and 'address' are optional now.

4. Conditional Types

Copy
T extends U ? X : Y

Copy
type IsString<T> = T extends string ? "Yes" : "No";

type A = IsString<string>; // "Yes"
type B = IsString<number>; // "No"

5. Dynamic parameter type

Copy
type Role = "admin" | "user";

interface BaseUser {
  name: string;
}

type UserWithRole<T extends Role> = T extends "admin"
  ? BaseUser & { permissions: string[] }
  : BaseUser;

const adminUser: UserWithRole<"admin"> = {
  name: "Alice",
  permissions: ["read", "write", "delete"],
};

const regularUser: UserWithRole<"user"> = {
  name: "Bob",
  // No 'permissions' field here
};

Copy
export enum EmailTemplateEnum {
    NewInquiryReceivedToAdmin = 4590262,
    NewInquiryReceivedToClient = 4576327,
    BidAcceptedOnOrderForClient = 4659400,
    BidAcceptedOnOrderForPartner = 4659358,
    BidEditedByPartnerForAdmin = 4659320,
    BidReceivedOnOrderForAdmin = 4659305,
    OrderBookingReceivedToAdmin = 4659255,
    OrderBookingReceivedToClient = 4659177,
    NotifyPartnerForOrderCreation = 4659288,
    OrderConfirmationByClientForPartner = 4659479,

    PaymentSuccessfulForClient = 4659518,
    PaymentSuccessfulForAdmin = 4736125,
    PaymentSuccessfulForPartner = 4736123,

    OrderFollowUp1 = 4659643,
    OrderFollowUp2 = 4659602,
    OrderFollowUp3 = 4659657,
}


// for auto complete based on choice of enum
// we will need to create all these 7 interface
export type EmailEnumToEmailVariableInterfaceMap = {
    [EmailTemplateEnum.NewInquiryReceivedToAdmin]: NewInquiryReceivedToAdminInterface;
    [EmailTemplateEnum.NewInquiryReceivedToClient]: NewInquiryReceivedToClientInterface;
    [EmailTemplateEnum.BidAcceptedOnOrderForClient]: BidAcceptedOnOrderForClientInterface;
    [EmailTemplateEnum.BidAcceptedOnOrderForPartner]: BidAcceptedOnOrderForPartnerInterface;
    [EmailTemplateEnum.BidEditedByPartnerForAdmin]: BidEditedByPartnerForAdminInterface;
    [EmailTemplateEnum.OrderBookingReceivedToAdmin]: OrderBookingReceivedToAdminInterface;
    [EmailTemplateEnum.OrderBookingReceivedToClient]: OrderBookingReceivedToClientInterface;
    [EmailTemplateEnum.NotifyPartnerForOrderCreation]: NotifyPartnerForOrderCreationInterface;
    [EmailTemplateEnum.OrderConfirmationByClientForPartner]: OrderConfirmationByClientForPartnerInterface;
    [EmailTemplateEnum.BidReceivedOnOrderForAdmin]: BidReceivedOnOrderForAdminInterface;
    [EmailTemplateEnum.OrderFollowUp1]: OrderFollowUpInterface;
    [EmailTemplateEnum.OrderFollowUp2]: OrderFollowUpInterface;
    [EmailTemplateEnum.OrderFollowUp3]: OrderFollowUpInterface;

    [EmailTemplateEnum.PaymentSuccessfulForClient]: PaymentSuccessfulForClientInterface;
    [EmailTemplateEnum.PaymentSuccessfulForPartner]: PaymentSuccessfulForPartnerInterface;
    [EmailTemplateEnum.PaymentSuccessfulForAdmin]: PaymentSuccessfulForAdminInterface;
};


async sendEmail<
        T extends EmailTemplateEnum,
        K extends EmailEnumToEmailVariableInterfaceMap[T],
    >(emailArgs: EmailProducerInterface<T, K>){}

Conclusion