TypeScript First Steps

### Back to the backend!

![Tyra Banks 'but then make it fashion' meme with TS logo](https://i.imgflip.com/a49tin.jpg)

- Install TS in the backend project
                - Create a `tsconfig.json` that extends from appropriate base(s)
                - Rename the `.js` files to `.ts`
                - Enable the `noEmit` option in `tsconfig.json`
                - Run `tsc`

![Christopher Walken cowbell meme, but make it types](https://i.imgflip.com/a49u6h.jpg)

### Types for non-TS deps

[DefinitelyTyped](https://github.com/DefinitelyTyped/DefinitelyTyped) FTW!

Community-maintained, npm-installable type declarations for popular JS packages that don't ship their own

e.g. to install types for Node:

```sh
                npm i -D @types/node
                ```

### Install all the types!

![Clean all the things meme](https://imgflip.com/s/meme/X-All-The-Y.jpg)

Install missing `@types/` packages for package dependencies

`npm i -D @types/<packageName>`

e.g. for `express`: `@types/express`

Define the missing custom types to fix the errors!

### Type assertions with `as`

```ts
                const maybeAnyElement = document.getElementById('my-button');
                const iSwearThisBtnExists =  possibleHTMLElement as HTMLButtonElement;
                ```

![Image of Austin Powers with text "I see you're using type assertions" "I too like to live dangerously"](https://i.imgflip.com/a4a0q4.jpg)

### Sharing types

### Type-only imports in `.ts` files

```ts
                import { actualValue, type JustType } from 'values.ts';
                ```

```ts
                import type { OneType, AnotherType } from 'types.js'
                ```

### Exporting types for reuse

```ts
                // bananas.ts
                export type Banana = 'banana';
                export type Plantain = 'plantain';
                ```

```ts
                // apples.ts
                type Apple = 'pink lady' | 'red delicious';
                const myApples: Apple[] = [];
                export { myApples, type Apple };
                ```

```ts
                // fruits.ts
                import type { Banana, Plantain } from 'bananas';
                import { myApples, type Apple } from 'apples';

const fruit: Banana | Apple = 'banana';
                ```
            
            
                --

# TS OSS FTW!

### Types & Databases

# [TypeORM](https://typeorm.io/)

### Data Validation
                
                Using TS types

[zod.dev](https://zod.dev)

_"TS-first schema validation with static type inference"_

- Provides typed objects to define data schemas
                - Checks that data has that shape at _runtime_ in JS
                - Lets TS infer corresponding type(s) at _compile time_
    
                --
                
                ### Declaring a Schema

```ts
                import { z } from "zod";

const User = z.object({
                    username: z.string(),
                });
                ```

### Validating data

```ts
                // throws an error if the data
                // doesn't match the schema
                User.parse({ username: "Ludwig" });
                ```

### Inferring TS type(s)

```ts
                // extract the inferred type
                type User = z.infer<typeof User>; // { username: string }
                ```