DEV Community: Adrien de Peretti

Mastering Recursive Types in TypeScript: Handling Depth Limitations Gracefully

Adrien de Peretti — Thu, 14 Nov 2024 10:06:16 +0000

Introduction

When working with deeply nested data structures in TypeScript, creating utility types to transform these structures is a common task. However, recursive types, while powerful, come with their own set of challenges.

One such challenge is controlling recursion depth effectively to prevent type computation from exceeding TypeScript's capabilities. This article will explore a common approach to incrementing and decrementing type-level numbers, identify its limitations, and present a robust solution for managing recursion depth using proper Increment and Decrement types.

🐛 The Problem with Basic Type-Level Number Operations

To better understand the limitations, let’s look at a naive approach often used when incrementing or decrementing numbers at the type level:

type Prev = [never, 0, 1, 2, 3, 4];
type Next = [1, 2, 3, 4, 5, 6];

type MinusOne = Prev[5]; // 👉 4
type PlusOne = Next[5];  // 👉 6

🍿 Problem Scenario: Deeply Nested Optional Properties

Suppose you have a deeply nested object type and want to make all
properties optional up to a specified level:

type DeepObject = {
  a: number;
  b: {
    c: string;
    d: {
      e: boolean;
      f: {
        g: string;
        h: {
          i: number;
          j: {
            k: string;
          };
        };
      };
    };
  };
};

With a naive, hardcoded approach, managing the depth at which properties become optional would look like this:

type Prev = [never, 0, 1, 2, 3, 4];

type DeepOptional<
  T,
  Limit extends number = 1
> = Limit extends never
  ? never
  : {
      [K in keyof T]?: T[K] extends object
        ? DeepOptional<T[K], Prev[Limit]>
        : T[K];
    };

Explanation:

DeepOptional makes properties optional up to Limit.
The Limit will be used to get the decremented value from the static tuple.

Example Usage:

type NewDeepObject = DeepOptional<DeepObject, 3>;

// Result:
// {
//   a?: number;
//   b?: {
//     c?: string;
//     d?: {
//       e?: boolean;
//       f?: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

type NewDeepObject = DeepOptional<DeepObject, 1>;

// Result:
// {
//   a?: number;
//   b?: {
//     c: string;
//     d: {
//       e: boolean;
//       f: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

✋ Issues with This Approach

Limited Range: This approach is only as flexible as the predefined arrays Prev and Next. If you need to increment or decrement numbers beyond the length of these arrays, you have to extend them manually, which is cumbersome and error-prone.
Scalability: As your needs evolve, managing these arrays becomes increasingly complex, making this approach impractical for larger-scale type operations.

🎯 A More Robust Solution: Tuple-Based Increment and Decrement Types

To overcome the limitations of predefined arrays, we can use tuple manipulation to create type-safe Increment and Decrement operations that scale dynamically.

🏗️ Key Building Blocks

Length Utility: A type to get the length of a tuple:

type Length<T extends any[]> = (T extends { length: number } ? T["length"] : never) & number;

TupleOf: A type that generates a tuple of N elements:

type TupleOf<N extends number, T extends unknown[] = []> = Length<T> extends N
  ? T
  : TupleOf<N, [...T, unknown]>;

Pop Utility: A type that removes the last element of a tuple:

type Pop<T extends any[]> = T extends [...infer U, unknown] ? U : never;

Increment and Decrement:

// Increment adds an element to a tuple, effectively creating N + 1
type Increment<N extends number> = Length<[1, ...TupleOf<N>]>;

// Decrement removes an element from a tuple, effectively creating N - 1
type Decrement<N extends number> = Length<Pop<TupleOf<N>>>;

🍿 Applying Increment and Decrement: A Practical Example

Let’s explore how these utility types can be applied to a more complex real-world problem: making properties of an object optional up to a certain depth.

Problem Scenario: Deeply Nested Optional Properties

Suppose you have a deeply nested object type and want to make all
properties optional up to a specified level:

type DeepObject = {
  a: number;
  b: {
    c: string;
    d: {
      e: boolean;
      f: {
        g: string;
        h: {
          i: number;
          j: {
            k: string;
          };
        };
      };
    };
  };
};

With a naive, hardcoded approach, managing the depth at which properties become optional would be complex. Here’s how a type-safe DeepOptional utility can solve this:

Implementing DeepOptional

type DeepOptional<
  T,
  Limit extends number = 1,
  CurrentLevel extends number = 0
> = CurrentLevel extends Limit
  ? T
  : {
      [K in keyof T]?: T[K] extends object
        ? DeepOptional<T[K], Limit, Increment<CurrentLevel>>
        : T[K];
    };

Explanation:

DeepOptional makes properties optional up to Limit.
The type increments CurrentLevel recursively until it matches Limit, at which point it stops recursing and returns T.
The Increment<CurrentLevel> ensures type-safe recursion without manual array mappings.

Example Usage:

type NewDeepObject = DeepOptional<DeepObject, 3>;

// Result:
// {
//   a?: number;
//   b?: {
//     c?: string;
//     d?: {
//       e?: boolean;
//       f?: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

type NewDeepObject = DeepOptional<DeepObject, 1>;

// Result:
// {
//   a?: number;
//   b?: {
//     c: string;
//     d: {
//       e: boolean;
//       f: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

🕵️ Conclusion

At medusajs, we're committed to finding the most efficient and innovative solutions to overcome complex technical challenges. By leveraging tuple-based Increment and Decrement types, you can move beyond the limitations of basic type-level operations and create scalable, type-safe utilities. This method not only simplifies recursion depth management but also ensures you maintain the flexibility needed for intricate type operations without exceeding TypeScript’s type-checking limits.

Medusa-extender CLI

Adrien de Peretti — Fri, 11 Mar 2022 17:00:06 +0000

Medusa is an open source headless commerce platform that allows you to create your own store in a matter of minutes. Part of what makes Medusa a good choice for your e-commerce store is its extensibility.

Medusa-extender is a package that takes your medusa project to the next level. Since the medusa-extender provides quite a lot of features, a new tool has been created to make things even easier to use.

Here, we will see what features the CLI does provides you and how to use them.

API Reference

To make things easier for you, the project comes with a CLI that allow
you to generate any component with minimum code implementation and also
to be able to run the migrations and show the list of applied and to be applied migrations.

Commands references

Name	Alias	Description
`migrate`	`m`	Migrate the migrations that has not been applied yet. Can also show you the migrations already applied and to be applied.
`generate`	`g`	Generate a new component among: module, service, entity, repository, migration, validator, router, middleware

Command `generate` reference

Usage

./node_modules/.bin/medex g [option]

Options

Name	Alias	Description
`--module <name>`	`-m`	Generate a new module.
`--middleware <name>`	`-mi`	Generate a new middleware.
`--service <name>`	`-s`	Generate a new service.
`--router <name>`	`-r`	Generate a new router.
`--entity <name>`	`-e`	Generate a new entity.
`--repository <name>`	`-re`	Generate a new repository.
`--migration <name>`	`-mi`	Generate a new migration.
`--validator <name>`	`-va`	Generate a new validator.
`--path`	`-p`	specify the path where the component must be generated (by default the component will be generated at [`src/modules/<name>/<name>.<type>.ts`].

👉 Examples

Without specifying the location -p

./node_modules/.bin/medex g -m store

Generate the store modules at src/modules/store/store.module.ts

With specifying the location -p

./node_modules/.bin/medex g -m store -p src/modules

Generate the store modules at src/modules/store.module.ts

Command `migrate` reference

Usage

./node_modules/.bin/medex m [option]

Options

Name	Alias	Description
`--run`	`-r`	Run migrations up method.
`--show`	`-s`	Show all applied and non applied migrations.

Discussions

If you are interesting in participate to any discussions you can follow that links

Conclusion

This project needs a ⭐ from you. Don't forget to leave a star ⭐.

I hope that this new tool will help you enjoying the medusa-extender in a better way and that it will please the community ❤️

You can now easily manage your migrations and generate any components with a minimal implementation.

See you soon 🚀

MedusaJS and more

Adrien de Peretti — Fri, 28 Jan 2022 16:38:08 +0000

What is MedusaJS? 💚

👉 MedusaJS is not more that The Open Source Shopify alternative.
Create a headless commerce store in minutes and start your growth journey on a fast and flexible foundation.

I really like that project and, I found that for my needs I needed a solution to be able to extend medusa in a way I could be able to achieve anything I wanted to achieve.

Why MedusaJS ❔

Well, compared to other solutions, the learning curve is really smooth and you will find all the features that you really need. You can even move from Shopify to Medusa in just few minutes 👉 look at this
But I must talk about the community as well. Everybody trying to help each other, the team is always accessible and you can even get some 1:1 call if needed :)

But you want more? 📦

I have developed for my own project a tool that wrap medusajs and allow me to extend pretty much everything and rework the core architecture of my server (but without breaking any of the provided features).
Because I really like the community around, I have decided to put that work available as a public repository.

Do you want to give a feedback? 📣

If you ever think about using medusajs but that you finally thought that some features were missing. Well, now you have the full power to add them in no time.

👉 Take a look at medusa-extender

DEV Community: Adrien de Peretti

Mastering Recursive Types in TypeScript: Handling Depth Limitations Gracefully

Introduction

🐛 The Problem with Basic Type-Level Number Operations

🍿 Problem Scenario: Deeply Nested Optional Properties

✋ Issues with This Approach

🎯 A More Robust Solution: Tuple-Based Increment and Decrement Types

🏗️ Key Building Blocks

🍿 Applying Increment and Decrement: A Practical Example

Problem Scenario: Deeply Nested Optional Properties

🕵️ Conclusion

Medusa-extender CLI

API Reference

Commands references

Command generate reference

Usage

Options

Command migrate reference

Usage

Options

Discussions

Conclusion

MedusaJS and more

What is MedusaJS? 💚

Why MedusaJS ❔

But you want more? 📦

Do you want to give a feedback? 📣

Command `generate` reference

Command `migrate` reference