@nemmtor/ts-databuilders 0.0.1-alpha.2 → 0.0.1-alpha.20

package/README.md

@@ -1,14 +1,489 @@
 # 🧱 TS DataBuilders
-DataBuilder Generator is a lightweight CLI tool that automatically generates builder classes from annotated TypeScript types.
-Just add a @DataBuilder JSDoc tag, run one command, and get a fully-typed builder ready to use in your tests or factories.
+Automatically generate type-safe builder classes from your TypeScript types to write cleaner, more focused tests.
 
-Built with [Effect](https://effect.website/).
+## Installation
+Install the package:
+```bash
+# npm
+npm install -D @nemmtor/ts-databuilders
 
-[Read about TS DataBuilders.](http://www.natpryce.com/articles/000714.html)
+# pnpm
+pnpm add -D @nemmtor/ts-databuilders
 
-## 🚀 Features
-- 🔍 Scans your repo for specific pattern to understand what builders to build
-- ⚡ Generates builder classes with fluent withX() methods and sensible defaults
-- 🧩 Type-safe — builders are generated directly from your TypeScript types
-- 🧠 Fast and Memory-efficient — processes files asynchronously and incrementally via streams
-- 🛠️ Pluggable — works with any TypeScript project layout
+# yarn
+yarn add -D @nemmtor/ts-databuilders
+```
+
+## Configuration
+Configuration is optional - it fallbacks to sensible defaults.
+
+### Configure via CLI flags (optional):
+```bash
+pnpm ts-databuilders --include "src/**/*.ts{,x}" --output-dir src/__generated__ --jsdoc-tag DataBuilder
+```
+You can also provide configuration by going through interactive wizard:
+```bash
+pnpm ts-databuilders --wizard
+```
+
+### Configure via config file (optional)
+Ts-databuilders will try to find config file `ts-databuilders.json` in the root of your repository.
+Config file is optional.
+
+Example of default config file:
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/nemmtor/ts-databuilders/refs/heads/main/schema.json",
+  "jsdocTag": "DataBuilder",
+  "inlineDefaultJsdocTag": "DataBuilderDefault",
+  "withNestedBuilders": true,
+  "outputDir": "generated/builders",
+  "include": "src/**/*.ts{,x}",
+  "fileSuffix": ".builder",
+  "fileCase": "kebab",
+  "builderSuffix": "Builder",
+  "defaults": {
+    "string": "",
+    "number": 0,
+    "boolean": false
+  }
+}
+```
+
+You can generate a default configuration file by running `init` command:
+```bash
+pnpm ts-databuilders init
+```
+You can also generate it by providing values step by step in an interactive wizard:
+```bash
+pnpm ts-databuilders init --wizard
+```
+
+
+### Options Reference
+
+| Name (in config file)          | Flag (cli flags)                                                  | Description                             | Default              |
+|---------------|-------------------------------------------------------|-----------------------------------------|----------------------|
+| jsdocTag      | `--jsdoc-tag`                                         | JSDoc tag to mark types for generation  | `DataBuilder`        |
+| inlineDefaultJsdocTag      | `--inline-default-jsdoc-tag`                                         | JSDoc tag used to set default value of given field  | `DataBuilderDefault`        |
+| withNestedBuilders      | `--with-nested-builders`                                         | When set to true ts-databuilders will use nested builders approach  | `true`        |
+| outputDir     | `--output-dir -o`                                     | Output directory for generated builders | `generated/builders` |
+| include       | `--include -i`                                        | Glob pattern for source files           | `src/**/*.ts{,x}`    |
+| fileSuffix    | `--file-suffix`                                       | File suffix for builder files           | `.builder`           |
+| fileCase    | `--file-case`                                       | Naming convention for generated builder file, one of 3: `kebab`, `camel`, `pascal`           | `kebab`           |
+| builderSuffix | `--builder-suffix`                                    | Class name suffix                       | `Builder`            |
+| defaults      | `--default-string --default-number --default-boolean` | Default values for primitives           | See example above    |
+
+**Priority:** CLI flags > Config file > Built-in defaults
+
+#### Debugging
+In order to turn on debug logs pass a flag: `--log-level debug`.
+
+## Quick Start
+**1. Annotate your types with JSDoc:**
+```ts
+/**
+ * @DataBuilder
+ */
+type User = {
+  id: string;
+  email: string;
+  name: string;
+  isActive: boolean;
+}
+```
+**2. Generate builders:**
+```bash
+pnpm ts-databuilders
+```
+For the `User` type above, you'll get:
+```ts
+import type { User } from "...";
+import { DataBuilder } from "./data-builder";
+
+export class UserBuilder extends DataBuilder<User> {
+    constructor() {
+        super({
+          id: "",
+          email: "",
+          name: "",
+          isActive: false
+        });
+    }
+
+    withId(id: User['id']) {
+        return this.with({ id });
+    }
+
+    withEmail(email: User['email']) {
+        return this.with({ email });
+    }
+
+    withName(name: User['name']) {
+        return this.with({ name });
+    }
+
+    withIsActive(isActive: User['isActive']) {
+        return this.with({ isActive });
+    }
+}
+```
+
+**3. Use in your tests:**
+```ts
+import { UserBuilder } from '...';
+
+const testUser = new UserBuilder()
+  .withEmail('test@example.com')
+  .withIsActive(false)
+  .build();
+```
+
+## Why?
+Tests often become cluttered with boilerplate when you need to create complex objects just to test one specific field. DataBuilders let you focus on what matters:
+Imagine testing a case where document aggregate should emit an event when it successfully update it's content:
+```ts
+it('should emit a ContentUpdatedEvent', () => {
+  const aggregate = DocumentAggregate.create({
+    id: '1',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    content: 'old-content'
+  });
+  const userId = '1';
+
+  aggregate.updateContent({ updatedBy: userId, content: 'new-content' });
+
+  expect(...);
+})
+```
+Above code is obfuscated with all of the default values you need to provide in order to satisfy typescript.
+Where in reality the only thing specific to this single test is the fact that some new content was provided to `updateContent` method.
+
+Imagine even more complex scenario:
+```tsx
+it('should show validation error when email is invalid', async () => {
+  render(<ProfileForm defaultValues={{
+      firstName: '',
+      lastName: '',
+      age: 0,
+      socials: {
+        linkedin: '',
+        github: '',
+        website: '',
+        twitter: '',
+      },
+      address: {
+        street: '',
+        city: '',
+        state: '',
+        zip: '',
+      },
+      skills: [],
+      bio: '',
+      email: 'invalid-email'
+    }}
+  />)
+
+  await submitForm();
+
+  expect(...);
+})
+```
+Again - in reality you should only be worried about email, not about whole form data.
+
+Here's how above tests could be written with databuilders:
+```ts
+it('should emit a ContentUpdatedEvent', () => {
+  const aggregate = DocumentAggregate.create(
+    new CreateDocumentAggregatedPayloadBuilder().build()
+  );
+
+  aggregate.updateContent(
+    new UpdateDocumentContentPayloadBuilder().withContent('new-content').build()
+  );
+
+  expect(...);
+})
+```
+
+```tsx
+it('should show validation error when email is invalid', async () => {
+  render(<ProfileForm defaultValues={
+    new ProfileFormInputBuilder.withEmail('invalid-email').build()} />
+  )
+
+  await submitForm();
+
+  expect(...);
+})
+```
+
+This not only makes the test code less verbose but also highlights what is really being tested.
+
+**Why not use AI for that?** While AI can generate test data, ts-databuilders is fast, free and deterministic.
+
+[Read more about data builders.](http://www.natpryce.com/articles/000714.html)
+
+## Nested Builders
+> [!NOTE]
+> Nested builders can be turned off by using withNestedBuilders option. Check configuration section for more details.
+
+When your types contain complex nested objects, you can annotate their type definitions and TS DataBuilders will automatically generate nested builders, allowing you to compose them fluently.
+### Example
+
+**Input types:**
+```ts
+/**
+ * @DataBuilder
+ */
+export type User = {
+  name: string;
+  address: Address;
+};
+
+/**
+ * @DataBuilder
+ */
+export type Address = {
+  street: string;
+  city: string;
+  country: string;
+};
+```
+**Generated builders:**
+```ts
+export class UserBuilder extends DataBuilder<User> {
+    constructor() {
+        super({
+          name: "",
+          address: new AddressBuilder().build();
+        });
+    }
+
+    withName(name: User['name']) {
+        return this.with({ name });
+    }
+
+    withAddress(address: DataBuilder<User['address']>) {
+        return this.with({ address: address.build() });
+    }
+}
+
+export class AddressBuilder extends DataBuilder<Address> {
+    constructor() {
+        super({
+          street: "",
+          city: "",
+          country: ""
+        });
+    }
+
+    withStreet(street: Address['street']) {
+        return this.with({ street });
+    }
+
+    withCity(city: Address['city']) {
+        return this.with({ city });
+    }
+
+    withCountry(country: Address['country']) {
+        return this.with({ country });
+    }
+}
+```
+**Usage:**
+```ts
+// ✅ Compose builders fluently
+const user = new UserBuilder()
+  .withName('John Doe')
+  .withAddress(
+    new AddressBuilder()
+      .withStreet('123 Main St')
+      .withCity('New York')
+  )
+  .build();
+// {..., address: { street: "123 Main st", city: "New York", country: "" } }
+
+// ✅ Use default values
+const userWithDefaultAddress = new UserBuilder().build();
+// {..., address: { street: "", city: "", country: "" } }
+
+// ✅ Override just one nested field
+const userWithCity = new UserBuilder()
+  .withAddress(
+    new AddressBuilder()
+      .withCity('San Francisco')
+  )
+  .build();
+// {..., address: { street: "", city: "San Francisco", country: "" } }
+```
+
+## Inline Default Values
+> [!NOTE]
+> It's your responsibility to provide inline default value that satisfies expected type.
+
+While global defaults work well for most cases, sometimes you need field-specific default values. This is especially important for specialized string types like ISO dates, UUIDs etc.
+
+```typescript
+/** @DataBuilder */
+type Order = {
+  id: string;           // Empty string - won't work as UUID
+  createdAt: string;    // Empty string - Invalid Date!
+}
+
+// Generated:
+constructor() {
+  super({
+    id: "",
+    createdAt: "",  // new Date("") = Invalid Date
+  });
+}
+```
+
+Use `@DataBuilderDefault` JSDoc tag to override defaults per field:
+```typescript
+/** @DataBuilder */
+type Order = {
+  /** @DataBuilderDefault '550e8400-e29b-41d4-a716-446655440000' */
+  id: string;
+
+  /** @DataBuilderDefault '2025-11-05T15:32:58.727Z' */
+  createdAt: string;
+}
+
+// Generated:
+constructor() {
+  super({
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    createdAt: '2025-11-05T15:32:58.727Z',
+  });
+}
+```
+
+## Supported Types
+
+The library supports a wide range of TypeScript type features:
+
+✅ **Primitives & Built-ins**
+- `string`, `number`, `boolean`, `Date`
+- Literal types: `'active' | 'inactive'`, `1 | 2 | 3`
+
+✅ **Complex Structures**
+- Objects and nested objects
+- Arrays: `string[]`, `Array<number>`
+- Tuples: `[string, number]`
+- Records: `Record<string, string>` `Record<'foo' | 'bar', string>`
+
+✅ **Type Operations**
+- Unions: `string | number | true | false`
+- Intersections: `A & B`
+- Utility types: `Pick<T, K>`, `Omit<T, K>`, `Partial<T>`, `Required<T>`, `Readonly<T>`, `Extract<T, U>`, `NonNullable<T>`
+- Branded types: `type UserId = string & { __brand: 'UserId' }`
+
+✅ **References**
+- Type references from the same file
+- Type references from other files
+- External library types (e.g., `z.infer<typeof schema>`)
+
+**For a comprehensive example** of supported types, check out the [example-data/bar.ts](https://github.com/nemmtor/ts-databuilders/blob/main/example-data/bar.ts) file in the repository. This file is used during development and demonstrates complex real-world type scenarios.
+
+## Important Rules & Limitations
+
+### Unique Builder Names
+Each type annotated with the JSDoc tag must have a **unique name** across your codebase:
+```ts
+// ❌ Error: Duplicate builder names
+// In file-a.ts
+/** @DataBuilder */
+export type User = { name: string };
+
+// In file-b.ts
+/** @DataBuilder */
+export type User = { email: string };  // 💥 Duplicate!
+```
+
+### Exported Types Only
+Types must be **exported** to generate builders:
+```ts
+// ❌ Won't work
+/** @DataBuilder */
+type User = { name: string };
+
+// ✅ Works
+/** @DataBuilder */
+export type User = { name: string };
+```
+
+### Type Aliases Only
+Currently, only **type aliases** are supported as root builder types. Interfaces, classes etc. are not supported:
+```ts
+// ❌ Not supported
+/** @DataBuilder */
+export interface User {
+  name: string;
+}
+
+// ❌ Not supported
+/** @DataBuilder */
+export class User {
+  name: string;
+}
+
+// ✅ Supported
+/** @DataBuilder */
+export type User = {
+  name: string;
+};
+```
+
+### Unsupported TypeScript Features
+
+Some TypeScript features are not yet supported and will cause generation errors:
+
+- **Recursive types**: Types that reference themselves
+```ts
+  // ❌ Not supported
+  type TreeNode = {
+    value: string;
+    children: TreeNode[];  // Self-reference
+  };
+```
+
+- **Function types**: Properties that are functions
+```ts
+  // ❌ Not supported
+  type WithCallback = {
+    onSave: (data: string) => void;
+  };
+```
+
+- typeof, keyof, unknown
+
+### Alpha Stage
+⚠️ **This library is in active development**
+
+- Breaking changes may occur
+- Not all edge cases are covered yet
+- Test thoroughly before using in production
+
+**Found an issue?** Please [report it on GitHub](https://github.com/nemmtor/ts-databuilders/issues) with:
+- A minimal reproducible example (if possible)
+- The type definition causing the issue
+- The error message received
+- Your `ts-databuilders.json` config and any provided CLI flags (if applicable)
+
+You can also turn on debug logs by passing `--log-level debug` flag.
+
+Your feedback helps improve the library for everyone! 🙏
+
+## Similar Projects
+- [effect-builder](https://github.com/slashlifeai/effect-builder) - a runtime library for building objects with Effect Schema validation.
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR on [GitHub](https://github.com/nemmtor/ts-databuilders).
+
+## License
+
+MIT © [nemmtor](https://github.com/nemmtor)

package/dist/main.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
-import*as We from"@effect/platform-node/NodeContext";import*as Ge from"@effect/platform-node/NodeRuntime";import{Effect as ht}from"effect";import*as Ye from"effect/Layer";import*as A from"@effect/cli/Command";import*as K from"effect/Layer";import*as ke from"@effect/platform/FileSystem";import*as F from"effect/Effect";import{FileSystem as ye}from"@effect/platform";import*as Se from"@effect/platform/Path";import*as ge from"effect/Context";import*as T from"effect/Effect";import*as w from"effect/Option";import*as d from"effect/Schema";import*as me from"effect/Context";import*as fe from"effect/Effect";import*as pe from"effect/Layer";class z extends me.Tag("Process")(){}var ue=pe.succeed(z,z.of({cwd:fe.sync(()=>process.cwd())}));var ze="ts-databuilders.json",$=d.Struct({jsdocTag:d.NonEmptyTrimmedString,outputDir:d.NonEmptyTrimmedString,include:d.NonEmptyTrimmedString,fileSuffix:d.NonEmptyTrimmedString,builderSuffix:d.NonEmptyTrimmedString,defaults:d.Struct({string:d.String,number:d.NumberFromString,boolean:d.BooleanFromString})}),Ee=$.make({jsdocTag:"DataBuilder",outputDir:"generated/builders",include:"src/**/*.ts{,x}",fileSuffix:".builder",builderSuffix:"Builder",defaults:{string:"",number:0,boolean:!1}}),Je=$.pipe(d.omit("defaults"),d.extend(d.Struct({$schema:d.optional(d.String),defaults:d.Struct({string:d.String,number:d.Number,boolean:d.Boolean}).pipe(d.partial)})),d.partial);class x extends ge.Tag("Configuration")(){}var Ce=(t)=>T.gen(function*(){let i=yield*(yield*z).cwd,c=(yield*Se.Path).join(i,ze),r=yield*He(c),p=yield*Ve({providedConfiguration:t,configFileContent:r});return x.of(p)}),Ve=(t)=>T.gen(function*(){let n=qe({provided:t.providedConfiguration,fileContent:t.configFileContent});return{builderSuffix:yield*n("builderSuffix"),include:yield*n("include"),fileSuffix:yield*n("fileSuffix"),jsdocTag:yield*n("jsdocTag"),outputDir:yield*n("outputDir"),defaults:{...Ee.defaults,...yield*n("defaults")}}}),qe=(t)=>(n)=>t.provided[n].pipe(T.orElse(()=>w.flatMap(t.fileContent,(i)=>w.fromNullable(i[n]))),T.orElseSucceed(()=>Ee[n])),He=(t)=>T.gen(function*(){let n=yield*ye.FileSystem;if(yield*T.orDie(n.exists(t))){let e=yield*Qe(t),c=yield*d.decodeUnknown(Je)(e);return w.some(c)}else return w.none()}),Qe=(t)=>T.gen(function*(){let n=yield*ye.FileSystem,i=yield*T.orDie(n.readFileString(t));return yield*T.try({try:()=>JSON.parse(i),catch:(e)=>`[FileSystem] Unable to read and parse JSON file from '${t}': ${String(e)}`})}).pipe(T.orDie);import J from"node:path";import*as be from"@effect/platform/FileSystem";import*as O from"effect/Effect";import*as C from"effect/Match";import{Project as et}from"ts-morph";var Q=(t)=>t.replace(/([a-z0-9])([A-Z])/g,"$1-$2").replace(/([A-Z])([A-Z][a-z])/g,"$1-$2").replace(/_/g,"-").toLowerCase(),ae=(t)=>{return t.split(/[-_\s]+/).flatMap((n)=>n.split(/(?=[A-Z])/)).filter(Boolean).map((n)=>n.charAt(0).toUpperCase()+n.slice(1).toLowerCase()).join("")},se=(t)=>{return t.split(/[-_\s]+/).flatMap((i)=>i.split(/(?=[A-Z])/)).filter(Boolean).map((i,e)=>{let c=i.toLowerCase();return e===0?c:c.charAt(0).toUpperCase()+c.slice(1)}).join("")};var Te=(t)=>{let{fieldName:n,optional:i,typeName:e,isNestedBuilder:c}=t,r=n.replaceAll("'","").replaceAll('"',""),p=se(r),s=`with${ae(r)}`,l=[`return this.with({ ${n}: ${p} });`],o=[`return this.with({ ${n}: ${p}.build() });`],a=c?o:l,g=[`if (!${p}) {`,`  const { "${r}": _unused, ...rest } = this.build();`,"  return this.with(rest);","}"],y=i?[...g,...a]:a,h=`${e}['${r}']`;return{name:s,isPublic:!0,parameters:[{name:p,type:c?`DataBuilder<${h}>`:h}],statements:y}};class X extends O.Service()("@TSDataBuilders/BuilderGenerator",{effect:O.gen(function*(){let t=yield*be.FileSystem,{outputDir:n,fileSuffix:i,builderSuffix:e,defaults:c}=yield*x,r=(p)=>C.value(p).pipe(C.when({kind:"STRING"},()=>`"${c.string}"`),C.when({kind:"NUMBER"},()=>c.number),C.when({kind:"BOOLEAN"},()=>c.boolean),C.when({kind:"UNDEFINED"},()=>"undefined"),C.when({kind:"DATE"},()=>"new Date()"),C.when({kind:"ARRAY"},()=>"[]"),C.when({kind:"LITERAL"},(s)=>s.literalValue),C.when({kind:"TYPE_CAST"},(s)=>r(s.baseTypeMetadata)),C.when({kind:"TUPLE"},(s)=>{return`[${s.members.map((o)=>r(o)).map((o)=>`${o}`).join(", ")}]`}),C.when({kind:"TYPE_LITERAL"},(s)=>{return`{${Object.entries(s.metadata).filter(([o,{optional:a}])=>!a).map(([o,a])=>`${o}: ${r(a)}`).join(", ")}}`}),C.when({kind:"RECORD"},(s)=>{if(s.keyType.kind==="STRING"||s.keyType.kind==="NUMBER")return"{}";let l=r(s.keyType),o=r(s.valueType);return`{${l}: ${o}}`}),C.when({kind:"UNION"},(s)=>{let o=s.members.slice().sort((a,g)=>{let y=xe.indexOf(a.kind),h=xe.indexOf(g.kind);return(y===-1?1/0:y)-(h===-1?1/0:h)})[0];if(!o)return"never";return r(o)}),C.when({kind:"BUILDER"},(s)=>{return`new ${s.name}${e}().build()`}),C.exhaustive);return{generateBaseBuilder:O.fnUntraced(function*(){let p=J.resolve(n,"data-builder.ts");yield*t.writeFileString(p,tt)}),generateBuilder:O.fnUntraced(function*(p){let s=new et,l=p.name,o=J.resolve(n,`${Q(l)}${i}.ts`),a=s.createSourceFile(o,"",{overwrite:!0}),g=J.resolve(p.path),y=J.relative(J.dirname(o),g).replace(/\.ts$/,"");if(a.addImportDeclaration({namedImports:[l],isTypeOnly:!0,moduleSpecifier:y}),a.addImportDeclaration({namedImports:["DataBuilder"],moduleSpecifier:"./data-builder"}),p.shape.kind!=="TYPE_LITERAL")return yield*O.dieMessage("[BuilderGenerator]: Expected root type to be type literal");[...new Set(rt(p.shape.metadata))].forEach((b)=>{a.addImportDeclaration({namedImports:[`${b}${e}`],moduleSpecifier:`./${Q(b)}${i}`})});let k=Object.entries(p.shape.metadata).filter(([b,{optional:B}])=>!B).map(([b,B])=>`${b}: ${B.kind==="TYPE_CAST"?`${r(B)} as ${l}['${b}']`:r(B)}`),N=Object.entries(p.shape.metadata).map(([b,{optional:B,kind:H}])=>Te({fieldName:b,optional:B,typeName:l,isNestedBuilder:H==="BUILDER"})),Z=`{
-  ${k.join(`,
+import*as ft from"@effect/platform-node/NodeContext";import*as pt from"@effect/platform-node/NodeRuntime";import*as ut from"effect/Effect";import*as mt from"effect/Layer";import*as gt from"effect/Logger";import*as St from"effect/LogLevel";import*as J from"@effect/cli/Command";import*as r from"@effect/cli/Options";import*as ne from"effect/Layer";import{Project as xt}from"ts-morph";import*as Ie from"@effect/platform/FileSystem";import*as ke from"@effect/platform/Path";import*as m from"effect/Effect";import*as D from"effect/Match";import*as Ye from"effect/Option";import*as H from"effect/Schema";import*as Ce from"@effect/platform/FileSystem";import*as je from"@effect/platform/Path";import*as Ge from"effect/Context";import*as x from"effect/Effect";import*as k from"effect/Option";import*as i from"effect/Schema";var C={jsdocTag:"JSDoc tag used to mark types for data building generation.",inlineDefaultJsdocTag:"JSDoc tag used to set default value of given field.",withNestedbuilders:"When set to true ts-databuilders will use nested builders approach.",outputDir:"Output directory for generated builders.",include:"Glob pattern for files included while searching for jsdoc tag.",fileSuffix:"File suffix for created builder files.",fileCase:"Naming convention for generated builder file",builderSuffix:"Suffix for generated classes.",defaults:"Default values to be used in data builder constructor.",defaultString:"Default string value to be used in data builder constructor.",defaultNumber:"Default number value to be used in data builder constructor.",defaultBoolean:"Default boolean value to be used in data builder constructor."};import*as ue from"effect/Effect";var R=class extends ue.Service()("@TSDataBuilders/Process",{succeed:{cwd:ue.sync(()=>process.cwd())}}){};var Tt=e=>e!==void 0,re=e=>Object.fromEntries(Object.entries(e).filter(([o,c])=>Tt(c)));var Oe="ts-databuilders.json",Et=i.Struct({jsdocTag:i.NonEmptyTrimmedString,inlineDefaultJsdocTag:i.NonEmptyTrimmedString,withNestedBuilders:i.Boolean,outputDir:i.NonEmptyTrimmedString,include:i.NonEmptyTrimmedString,fileSuffix:i.NonEmptyTrimmedString,fileCase:i.Literal("kebab","camel","pascal"),builderSuffix:i.NonEmptyTrimmedString,defaults:i.Struct({string:i.String,number:i.Number,boolean:i.Boolean})}),j=Et.make({jsdocTag:"DataBuilder",inlineDefaultJsdocTag:"DataBuilderDefault",withNestedBuilders:!0,outputDir:"generated/builders",include:"src/**/*.ts{,x}",fileSuffix:".builder",fileCase:"kebab",builderSuffix:"Builder",defaults:{string:"",number:0,boolean:!1}}),De=i.Struct({$schema:i.optional(i.String),jsdocTag:i.String.pipe(i.annotations({description:C.jsdocTag})),inlineDefaultJsdocTag:i.String.pipe(i.annotations({description:C.inlineDefaultJsdocTag})),withNestedBuilders:i.Boolean.pipe(i.annotations({description:C.withNestedbuilders})),outputDir:i.String.pipe(i.annotations({description:C.outputDir})),include:i.String.pipe(i.annotations({description:C.include})),fileSuffix:i.String.pipe(i.annotations({description:C.fileSuffix})),fileCase:i.Literal("kebab","camel","pascal").pipe(i.annotations({description:C.fileCase})),builderSuffix:i.String.pipe(i.annotations({description:C.builderSuffix})),defaults:i.Struct({string:i.String.pipe(i.annotations({description:C.defaultString})),number:i.Number.pipe(i.annotations({description:C.defaultNumber})),boolean:i.Boolean.pipe(i.annotations({description:C.defaultBoolean}))}).pipe(i.partial,i.annotations({description:C.defaults}))}).pipe(i.partial),L=class extends Ge.Tag("Configuration")(){},G=i.Struct({jsdocTag:i.NonEmptyTrimmedString,inlineDefaultJsdocTag:i.NonEmptyTrimmedString,withNestedBuilders:i.BooleanFromString,outputDir:i.NonEmptyTrimmedString,include:i.NonEmptyTrimmedString,fileSuffix:i.NonEmptyTrimmedString,fileCase:i.Literal("kebab","camel","pascal"),builderSuffix:i.NonEmptyTrimmedString,defaultString:i.String,defaultNumber:i.NumberFromString,defaultBoolean:i.BooleanFromString}),_e=e=>x.gen(function*(){yield*x.logDebug("[Configuration]: Loading configuration");let c=yield*(yield*R).cwd,d=(yield*je.Path).join(c,Oe),a=yield*Ot(d),E=yield*Nt({fromCLI:e,fromConfigFile:a});return L.of(E)}),Nt=e=>x.gen(function*(){let o=Ct(e),c=k.flatMap(e.fromConfigFile,E=>k.fromNullable(E.defaults)).pipe(k.map(E=>re(E)),k.getOrElse(()=>({}))),f=re({string:e.fromCLI.defaultString.pipe(k.getOrUndefined),number:e.fromCLI.defaultNumber.pipe(k.getOrUndefined),boolean:e.fromCLI.defaultBoolean.pipe(k.getOrUndefined)}),d={...c,...f},a={builderSuffix:yield*o("builderSuffix"),include:yield*o("include"),withNestedBuilders:yield*o("withNestedBuilders"),fileSuffix:yield*o("fileSuffix"),fileCase:yield*o("fileCase"),jsdocTag:yield*o("jsdocTag"),inlineDefaultJsdocTag:yield*o("inlineDefaultJsdocTag"),outputDir:yield*o("outputDir"),defaults:{...j.defaults,...d}};return yield*x.logDebug(`[Configuration]: Resolving config with value: ${JSON.stringify(a,null,4)}`),a}),Ct=e=>o=>e.fromCLI[o].pipe(x.orElse(()=>k.flatMap(e.fromConfigFile,c=>k.fromNullable(c[o]))),x.orElseSucceed(()=>j[o])),Ot=e=>x.gen(function*(){let o=yield*Ce.FileSystem;if(yield*x.orDie(o.exists(e))){yield*x.logDebug("[Configuration]: Found config file - attempting to read it");let f=yield*Dt(e),d=yield*i.decodeUnknown(De)(f);return k.some(d)}else return yield*x.logDebug("[Configuration]: No config file found"),k.none()}),Dt=e=>x.gen(function*(){let o=yield*Ce.FileSystem,c=yield*x.orDie(o.readFileString(e));return yield*x.try({try:()=>JSON.parse(c),catch:f=>`[FileSystem] Unable to read and parse JSON file from '${e}': ${String(f)}`})}).pipe(x.orDie);import*as B from"effect/Schema";var be=B.transform(B.String,B.String.pipe(B.brand("KebabCase")),{decode:e=>e.replace(/([a-z0-9])([A-Z])/g,"$1-$2").replace(/([A-Z])([A-Z][a-z])/g,"$1-$2").replace(/_/g,"-").toLowerCase(),encode:e=>e}),we=B.transform(B.String,B.String.pipe(B.brand("PascalCase")),{decode:e=>e.split(/[-_\s]+/).flatMap(o=>o.split(/(?=[A-Z])/)).filter(Boolean).map(o=>o.charAt(0).toUpperCase()+o.slice(1).toLowerCase()).join(""),encode:e=>e}),xe=B.transform(B.String,B.String.pipe(B.brand("CamelCase")),{decode:e=>e.split(/[-_\s]+/).flatMap(o=>o.split(/(?=[A-Z])/)).filter(Boolean).map((o,c)=>{let f=o.toLowerCase();return c===0?f:f.charAt(0).toUpperCase()+f.slice(1)}).join(""),encode:e=>e});import{randomUUID as wt}from"crypto";import*as me from"effect/Effect";var z=class extends me.Service()("@TSDataBuilders/IdGenerator",{succeed:{generateUuid:me.sync(()=>wt())}}){};var ge=class extends m.Service()("@TSDataBuilders/BuilderGenerator",{effect:m.gen(function*(){let o=yield*Ie.FileSystem,c=yield*ke.Path,f=yield*R,d=yield*L,a=yield*z,{fileSuffix:E,builderSuffix:O,defaults:g,fileCase:T}=d,u=m.fnUntraced(function*(n){return yield*{kebab:be.pipe(H.decode),pascal:we.pipe(H.decode),camel:xe.pipe(H.decode)}[T](n)}),s=n=>Ye.getOrUndefined(n.inlineDefault)??D.value(n).pipe(D.when({kind:"STRING"},()=>`"${g.string}"`),D.when({kind:"NUMBER"},()=>g.number),D.when({kind:"BOOLEAN"},()=>g.boolean),D.when({kind:"UNDEFINED"},()=>{}),D.when({kind:"BIGINT"},()=>"BigInt(0)"),D.when({kind:"SYMBOL"},()=>"Symbol('')"),D.when({kind:"ANY"},()=>{}),D.when({kind:"UNKNOWN"},()=>{}),D.when({kind:"NULL"},()=>null),D.when({kind:"DATE"},()=>"new Date()"),D.when({kind:"ARRAY"},()=>"[]"),D.when({kind:"LITERAL"},l=>l.literalValue),D.when({kind:"TYPE_CAST"},l=>s(l.baseTypeMetadata)),D.when({kind:"TUPLE"},l=>`[${l.members.map(P=>s(P)).map(P=>`${P}`).join(", ")}]`),D.when({kind:"TYPE_LITERAL"},l=>`{${Object.entries(l.metadata).filter(([P,{optional:y}])=>!y).map(([P,y])=>`${P}: ${s(y)}`).join(", ")}}`),D.when({kind:"RECORD"},l=>{if(l.keyType.kind==="STRING"||l.keyType.kind==="NUMBER")return"{}";let S=s(l.keyType),P=s(l.valueType);return`{${S}: ${P}}`}),D.when({kind:"UNION"},l=>{let P=l.members.slice().sort((y,N)=>{let I=Je.indexOf(y.kind),w=Je.indexOf(N.kind);return(I===-1?1/0:I)-(w===-1?1/0:w)})[0];return P?s(P):"never"}),D.when({kind:"BUILDER"},l=>`new ${l.name}${O}().build()`),D.exhaustive);return{generateBaseBuilder:m.fnUntraced(function*(){let n=c.join(yield*f.cwd,d.outputDir),l=c.resolve(n,`${yield*u("dataBuilder")}.ts`);yield*m.logDebug(`[Builders]: Creating base builder at ${l}`),yield*m.orDie(o.writeFileString(l,`${It}
+`))}),generateBuilder:m.fnUntraced(function*(n){let l=new xt,S=n.name;yield*m.logDebug(`[Builders]: Creating builder for ${S}`);let P=c.join(yield*f.cwd,d.outputDir),y=c.resolve(P,`${yield*u(S)}${E}.ts`);yield*m.logDebug(`[Builders]: Creating builder content for ${S}`);let N=l.createSourceFile(`__temp_${yield*a.generateUuid}.ts`,"",{overwrite:!0}),I=c.resolve(n.path),w=c.relative(c.dirname(y),I).replace(/\.ts$/,"");if(N.addImportDeclaration({namedImports:[S],isTypeOnly:!0,moduleSpecifier:w}),N.addImportDeclaration({namedImports:["DataBuilder"],moduleSpecifier:"./data-builder"}),n.shape.kind!=="TYPE_LITERAL")return yield*m.dieMessage("[BuilderGenerator]: Expected root type to be type literal");let b=[...new Set(kt(n.shape.metadata))];yield*m.forEach(b,F=>be.pipe(H.decode)(F).pipe(m.andThen(A=>N.addImportDeclaration({namedImports:[`${F}${O}`],moduleSpecifier:`./${A}${E}`}))),{concurrency:"unbounded"});let v=Object.entries(n.shape.metadata).filter(([F,{optional:A}])=>!A).map(([F,A])=>`${F}: ${A.kind==="TYPE_CAST"?`${s(A)} as ${S}['${F}']`:s(A)}`),Z=yield*m.all(Object.entries(n.shape.metadata).map(([F,{optional:A,kind:fe}])=>Pt({fieldName:F,optional:A,typeName:S,isNestedBuilder:fe==="BUILDER"})),{concurrency:"unbounded"}),W=`{
+  ${v.join(`,
   `)}
-}`;a.addClass({name:`${l}${e}`,isExported:!0,extends:`DataBuilder<${l}>`,methods:[{name:"constructor",statements:[`super(${Z});`]},...N]}),a.saveSync()})}})}){}var xe=["UNDEFINED","BOOLEAN","NUMBER","STRING","DATE","LITERAL","TYPE_LITERAL","ARRAY","TUPLE","RECORD"],tt=`export abstract class DataBuilder<T> {
+}`;N.addClass({name:`${S}${O}`,isExported:!0,extends:`DataBuilder<${S}>`,methods:[{name:"constructor",statements:[`super(${W});`]},...Z]}),yield*m.logDebug(`[Builders]: Saving builder content at ${y}`),yield*o.writeFileString(y,`${N.getText()}
+`)})}}),dependencies:[z.Default]}){},Je=["UNDEFINED","BOOLEAN","NUMBER","STRING","DATE","LITERAL","TYPE_LITERAL","ARRAY","TUPLE","RECORD"],It=`export abstract class DataBuilder<T> {
   private data: T;
 
   constructor(initialData: T) {
@@ -18,4 +20,5 @@ import*as We from"@effect/platform-node/NodeContext";import*as Ge from"@effect/p
     return this;
   }
 }
-`;function rt(t){let n=[];function i(e){switch(e.kind){case"BUILDER":n.push(e.name);break;case"TYPE_LITERAL":Object.values(e.metadata).forEach(i);break;case"UNION":case"TUPLE":e.members.forEach(i);break;case"RECORD":i(e.keyType),i(e.valueType);break}}return Object.values(t).forEach(i),n}class I extends F.Service()("@TSDataBuilders/Builders",{effect:F.gen(function*(){let t=yield*ke.FileSystem,n=yield*X,{outputDir:i}=yield*x;return{create:F.fnUntraced(function*(e){if(yield*t.exists(i))yield*t.remove(i,{recursive:!0});yield*t.makeDirectory(i,{recursive:!0}),yield*n.generateBaseBuilder();let r=e.map((l)=>l.name),p=r.filter((l,o)=>r.indexOf(l)!==o),s=[...new Set(p)];if(p.length>0)return yield*F.dieMessage(`Duplicated builders: ${s.join(", ")}`);yield*F.all(e.map((l)=>n.generateBuilder(l)),{concurrency:"unbounded"})})}}),dependencies:[X.Default]}){}import*as f from"@effect/cli/Options";import*as R from"effect/HashMap";import*as ee from"effect/Option";import*as P from"effect/Schema";var nt=f.text("jsdocTag").pipe(f.withDescription("JSDoc tag used to mark types for data building generation."),f.withSchema($.fields.jsdocTag),f.optional),ot=f.text("output-dir").pipe(f.withAlias("o"),f.withDescription("Output directory for generated builders."),f.withSchema($.fields.outputDir),f.optional),it=f.text("include").pipe(f.withAlias("i"),f.withDescription("Glob pattern for files included while searching for jsdoc tag."),f.withSchema($.fields.include),f.optional),at=f.text("file-suffix").pipe(f.withDescription("File suffix for created builder files."),f.withSchema($.fields.fileSuffix),f.optional),st=f.text("builder-suffix").pipe(f.withDescription("Suffix for generated classes."),f.withSchema($.fields.builderSuffix),f.optional),ct=f.keyValueMap("defaults").pipe(f.withDescription("Default values to be used in data builder constructor."),f.withSchema(P.HashMapFromSelf({key:P.Literal("string","number","boolean"),value:P.String}).pipe(P.transform($.fields.defaults,{decode:(t)=>{return{string:t.pipe(R.get("string"),ee.getOrElse(()=>"")),number:t.pipe(R.get("number"),ee.getOrElse(()=>"0")),boolean:t.pipe(R.get("boolean"),ee.getOrElse(()=>"false"))}},encode:(t)=>{return R.make(["string",t.string],["number",t.number],["boolean",t.boolean])},strict:!1}))),f.optional),Be={jsdocTag:nt,outputDir:ot,include:it,fileSuffix:at,builderSuffix:st,defaults:ct};import*as M from"effect/Chunk";import*as D from"effect/Effect";import*as $e from"effect/Function";import*as j from"effect/Option";import*as re from"effect/Stream";import*as Ne from"effect/Data";import*as De from"effect/Effect";import*as Fe from"effect/Stream";import{glob as lt}from"glob";class U extends De.Service()("@TSDataBuilders/TreeWalker",{succeed:{walk:(t)=>{return Fe.fromAsyncIterable(lt.stream(t,{cwd:".",nodir:!0}),(n)=>new ce({cause:n}))}}}){}class ce extends Ne.TaggedError("TreeWalkerError"){}import{FileSystem as dt}from"@effect/platform";import*as v from"effect/Effect";import*as L from"effect/Stream";class te extends v.Service()("@TSDataBuilders/FileContentChecker",{effect:v.gen(function*(){let t=yield*dt.FileSystem,n=new TextDecoder;return{check:v.fnUntraced(function*(i){let{content:e,filePath:c}=i;return yield*t.stream(c,{chunkSize:16384}).pipe(L.map((s)=>n.decode(s,{stream:!0})),L.mapAccum("",(s,l)=>{let o=s+l;return[o.slice(-e.length+1),o.includes(e)]}),L.find(Boolean),L.runCollect)})}})}){}class _ extends D.Service()("@TSDataBuilders/Finder",{effect:D.gen(function*(){let t=yield*te,{include:n,jsdocTag:i}=yield*x,e=`@${i}`;return{find:D.fnUntraced(function*(){return yield*(yield*U).walk(n).pipe(re.mapEffect((s)=>t.check({filePath:s,content:e}).pipe(D.map(M.map((l)=>l?j.some(s):j.none()))),{concurrency:"unbounded"}),re.runCollect,D.map(M.flatMap($e.identity)),D.map(M.filter((s)=>j.isSome(s))),D.map(M.map((s)=>s.value)))})}}),dependencies:[te.Default]}){}import*as Pe from"@effect/platform/FileSystem";import*as W from"effect/Data";import*as S from"effect/Effect";import*as q from"effect/Either";import{Project as pt,SyntaxKind as ie}from"ts-morph";import{randomUUID as mt}from"node:crypto";import*as V from"effect/Data";import*as m from"effect/Effect";import*as u from"effect/Match";import*as Oe from"effect/Option";import{Node as ft,SyntaxKind as E}from"ts-morph";class oe extends m.Service()("@TSDataBuilders/TypeNodeParser",{effect:m.gen(function*(){let{jsdocTag:t}=yield*x,n=(e)=>m.gen(function*(){let{type:c,contextNode:r,optional:p}=e,s=c.getProperties();if(!c.isObject()||s.length===0)return yield*new we({raw:c.getText(),kind:r.getKind()});let l={};for(let o of s){let a=o.getName(),g=o.getTypeAtLocation(r),y=o.isOptional(),h=r.getProject().createSourceFile(`__temp_${mt()}.ts`,`type __T = ${g.getText()}`,{overwrite:!0}),k=h.getTypeAliasOrThrow("__T").getTypeNodeOrThrow(),N=yield*m.suspend(()=>i({typeNode:k,optional:y}));l[a]=N,r.getProject().removeSourceFile(h)}return{kind:"TYPE_LITERAL",metadata:l,optional:p}}),i=(e)=>m.gen(function*(){let{typeNode:c,optional:r}=e,p=c.getKind(),s=u.value(p).pipe(u.when(u.is(E.StringKeyword),()=>m.succeed({kind:"STRING",optional:r})),u.when(u.is(E.NumberKeyword),()=>m.succeed({kind:"NUMBER",optional:r})),u.when(u.is(E.BooleanKeyword),()=>m.succeed({kind:"BOOLEAN",optional:r})),u.when(u.is(E.UndefinedKeyword),()=>m.succeed({kind:"UNDEFINED",optional:r})),u.when(u.is(E.ArrayType),()=>m.succeed({kind:"ARRAY",optional:r})),u.when(u.is(E.LiteralType),()=>m.succeed({kind:"LITERAL",literalValue:c.asKindOrThrow(E.LiteralType).getLiteral().getText(),optional:r})),u.when(u.is(E.TypeLiteral),()=>m.gen(function*(){let a=c.asKindOrThrow(E.TypeLiteral).getMembers();return{kind:"TYPE_LITERAL",metadata:yield*m.reduce(a,{},(y,h)=>m.gen(function*(){if(!h.isKind(E.PropertySignature))return y;let k=h.getTypeNode();if(!k)return y;let N=h.getNameNode().getText(),Z=h.hasQuestionToken(),b=yield*m.suspend(()=>i({typeNode:k,optional:Z}));return{...y,[N]:b}})),optional:r}})),u.when(u.is(E.ImportType),()=>m.gen(function*(){let o=c.asKindOrThrow(E.ImportType),a=o.getType(),g=a.getSymbol();if(!g)throw Error("TODO: missing symbol");let y=g.getDeclarations();if(y&&y.length>1)return yield*new le;let[h]=y;if(!h)return yield*new de;return yield*n({type:a,contextNode:o,optional:r})})),u.when(u.is(E.TupleType),()=>m.gen(function*(){let a=c.asKindOrThrow(E.TupleType).getElements(),g=yield*m.all(a.map((y)=>m.suspend(()=>i({typeNode:y,optional:!1}))));return{kind:"TUPLE",optional:r,members:g}})),u.when(u.is(E.TypeReference),()=>m.gen(function*(){let o=c.asKindOrThrow(E.TypeReference),a=o.getTypeName().getText();if(a==="Date")return{kind:"DATE",optional:r};if(a==="Array")return{kind:"ARRAY",optional:r};let g=o.getTypeArguments();if(a==="Record"){let[B,H]=g;if(!B||!H)return yield*new ne({kind:p,raw:c.getText()});let Ke=yield*m.suspend(()=>i({typeNode:B,optional:!1})),Ze=yield*m.suspend(()=>i({typeNode:H,optional:!1}));return{kind:"RECORD",keyType:Ke,valueType:Ze,optional:r}}if(["Pick","Omit","Partial","Required","Readonly","Extract","NonNullable"].includes(a))return yield*n({type:o.getType(),contextNode:o,optional:r});let h=o.getType().getAliasSymbol();if(!h)return yield*n({type:o.getType(),contextNode:o,optional:r});let k=h.getDeclarations();if(k&&k.length>1)return yield*new le;let[N]=k;if(!N)return yield*new de;let Z=h?.getJsDocTags().map((B)=>B.getName()).includes(t);if(!ft.isTypeAliasDeclaration(N))throw Error("TODO: for non-type-alias declarations (interfaces, etc.)");let b=N.getTypeNode();if(!b)return yield*new ne({kind:p,raw:c.getText()});if(!Z)return yield*m.suspend(()=>i({typeNode:b,optional:r}));return{kind:"BUILDER",name:N.getName(),optional:r}})),u.when(u.is(E.UnionType),()=>m.gen(function*(){let o=yield*m.all(c.asKindOrThrow(E.UnionType).getTypeNodes().map((a)=>m.suspend(()=>i({typeNode:a,optional:!1}))));return{kind:"UNION",optional:r,members:o}})),u.when(u.is(E.IntersectionType),()=>m.gen(function*(){let a=c.asKindOrThrow(E.IntersectionType).getTypeNodes(),g=[E.StringKeyword,E.NumberKeyword,E.BooleanKeyword],y=a.find((h)=>g.includes(h.getKind()));if(y&&a.length>1)return{kind:"TYPE_CAST",baseTypeMetadata:yield*m.suspend(()=>i({typeNode:y,optional:!1})),optional:r};throw Error("TODO: handle it")})),u.option);if(Oe.isNone(s))return yield*new ne({kind:p,raw:c.getText()});return yield*s.value});return{generateMetadata:i}})}){}class ne extends V.TaggedError("UnsupportedSyntaxKindError"){}class le extends V.TaggedError("MultipleSymbolDeclarationsError"){}class de extends V.TaggedError("MissingSymbolDeclarationError"){}class we extends V.TaggedError("CannotBuildTypeReferenceMetadata"){}class G extends S.Service()("@TSDataBuilders/Parser",{effect:S.gen(function*(){let t=yield*Pe.FileSystem,n=yield*oe,{jsdocTag:i}=yield*x;return{generateBuildersMetadata:S.fnUntraced(function*(e){let c=yield*t.readFileString(e),r=yield*S.try({try:()=>{return new pt().createSourceFile(e,c,{overwrite:!0}).getTypeAliases().filter((g)=>g.getJsDocs().flatMap((y)=>y.getTags().flatMap((h)=>h.getTagName())).includes(i)).map((g)=>{let y=g.getName();if(!g.isExported())return q.left(new Ae({path:e,typeName:y}));let h=g.getTypeNode();if(!(h?.isKind(ie.TypeLiteral)||h?.isKind(ie.TypeReference)))return q.left(new Me({path:e,typeName:g.getName()}));return q.right({name:g.getName(),node:h})}).filter(Boolean)},catch:(l)=>new Le({cause:l})}),p=yield*S.all(r.map((l)=>l));return yield*S.all(p.map(({name:l,node:o})=>n.generateMetadata({typeNode:o,optional:!1}).pipe(S.map((a)=>({name:l,shape:a,path:e})),S.catchTags({UnsupportedSyntaxKindError:(a)=>S.fail(new Ie({kind:a.kind,raw:a.raw,path:e,typeName:l})),CannotBuildTypeReferenceMetadata:(a)=>S.fail(new Re({kind:a.kind,raw:a.raw,path:e,typeName:l}))}))))},S.catchTags({ParserError:(e)=>S.die(e),UnexportedDatabuilderError:(e)=>S.dieMessage(`[Parser]: Unexported databuilder ${e.typeName} at ${e.path}`),RichUnsupportedSyntaxKindError:(e)=>S.dieMessage(`[Parser]: Unsupported syntax kind of id: ${e.kind} with raw type: ${e.raw} found in type ${e.typeName} in file ${e.path}`),RichCannotBuildTypeReferenceMetadata:(e)=>S.dieMessage(`[Parser]: Cannot build type reference metadata with kind of id: ${e.kind} with raw type: ${e.raw} found in type ${e.typeName} in file ${e.path}. Is it a root of databuilder?`),UnsupportedBuilderTypeError:(e)=>S.dieMessage(`[Parser]: Unsupported builder type ${e.typeName} in file ${e.path}.`)}))}}),dependencies:[oe.Default]}){}class Le extends W.TaggedError("ParserError"){}class Ae extends W.TaggedError("UnexportedDatabuilderError"){}class Me extends W.TaggedError("UnsupportedBuilderTypeError"){}class Ie extends W.TaggedError("RichUnsupportedSyntaxKindError"){}class Re extends W.TaggedError("RichCannotBuildTypeReferenceMetadata"){}import*as Ue from"effect/Chunk";import*as Y from"effect/Effect";import*as ve from"effect/Function";var je=Y.gen(function*(){let t=yield*_,n=yield*G,i=yield*I,e=yield*t.find(),c=yield*Y.all(Ue.map(e,(r)=>n.generateBuildersMetadata(r)),{concurrency:"unbounded"}).pipe(Y.map((r)=>r.flatMap(ve.identity)));if(c.length===0)return;yield*i.create(c)});var ut=A.make("ts-databuilders",Be),_e=ut.pipe(A.withHandler(()=>je),A.provide((t)=>K.mergeAll(_.Default,G.Default,I.Default,U.Default).pipe(K.provide(K.effect(x,Ce(t))))),A.run({name:"Typescript Databuilders generator",version:"v0.0.1"}));var yt=Ye.mergeAll(ue,We.layer);_e(process.argv).pipe(ht.provide(yt),Ge.runMain);
+`;function kt(e){let o=[];function c(f){switch(f.kind){case"BUILDER":o.push(f.name);break;case"TYPE_LITERAL":Object.values(f.metadata).forEach(c);break;case"UNION":case"TUPLE":f.members.forEach(c);break;case"RECORD":c(f.keyType),c(f.valueType);break}}return Object.values(e).forEach(c),o}var Pt=e=>m.gen(function*(){let{fieldName:o,optional:c,typeName:f,isNestedBuilder:d}=e,a=o.replaceAll("'","").replaceAll('"',""),E=yield*xe.pipe(H.decode)(a),O=`with${yield*we.pipe(H.decode)(a)}`,g=[`return this.with({ ${o}: ${E} });`],T=[`return this.with({ ${o}: ${E}.build() });`],u=d?T:g,s=[`if (!${E}) {`,`  const { "${a}": _unused, ...rest } = this.build();`,"  return this.with(rest);","}"],n=c?[...s,...u]:u,l=`${f}['${a}']`;return{name:O,isPublic:!0,parameters:[{name:E,type:d?`DataBuilder<${l}>`:l}],statements:n}}),Q=class extends m.Service()("@TSDataBuilders/BuildersGenerator",{effect:m.gen(function*(){let o=yield*Ie.FileSystem,c=yield*ge,f=yield*R,d=yield*ke.Path,a=yield*L;return{create:m.fnUntraced(function*(E){let O=d.join(yield*f.cwd,a.outputDir);(yield*m.orDie(o.exists(O)))&&(yield*m.logDebug(`[Builders]: Removing already existing output directory at ${O}`),yield*m.orDie(o.remove(O,{recursive:!0}))),yield*m.logDebug(`[Builders]: Creating output directory at ${O}`),yield*m.orDie(o.makeDirectory(O,{recursive:!0})),yield*c.generateBaseBuilder();let T=E.map(n=>n.name),u=T.filter((n,l)=>T.indexOf(n)!==l),s=[...new Set(u)];if(u.length>0)return yield*m.dieMessage(`Duplicated builders: ${s.join(", ")}`);yield*m.all(E.map(n=>c.generateBuilder(n)),{concurrency:"unbounded"})})}}),dependencies:[ge.Default]}){};import*as Ve from"@effect/platform/FileSystem";import*as Ze from"@effect/platform/Path";import*as ze from"effect/Effect";import*as U from"effect/Option";import*as qe from"effect/Schema";var He=e=>ze.gen(function*(){let o=yield*R,c=yield*Ve.FileSystem,f=yield*o.cwd,a=(yield*Ze.Path).join(f,Oe),E=re({string:e.defaultString.pipe(U.getOrUndefined),number:e.defaultNumber.pipe(U.getOrUndefined),boolean:e.defaultBoolean.pipe(U.getOrUndefined)}),O=yield*qe.decode(De)({$schema:"https://raw.githubusercontent.com/nemmtor/ts-databuilders/refs/heads/main/schema.json",builderSuffix:e.builderSuffix.pipe(U.getOrElse(()=>j.builderSuffix)),fileSuffix:e.fileSuffix.pipe(U.getOrElse(()=>j.fileSuffix)),fileCase:e.fileCase.pipe(U.getOrElse(()=>j.fileCase)),include:e.include.pipe(U.getOrElse(()=>j.include)),jsdocTag:e.jsdocTag.pipe(U.getOrElse(()=>j.jsdocTag)),inlineDefaultJsdocTag:e.inlineDefaultJsdocTag.pipe(U.getOrElse(()=>j.inlineDefaultJsdocTag)),withNestedBuilders:e.withNestedBuilders.pipe(U.getOrElse(()=>j.withNestedBuilders)),outputDir:e.outputDir.pipe(U.getOrElse(()=>j.outputDir)),defaults:{...j.defaults,...E}});yield*c.writeFileString(a,`${JSON.stringify(O,null,2)}
+`)});import*as ee from"effect/Chunk";import*as M from"effect/Effect";import*as ye from"effect/Option";import*as he from"effect/Stream";import*as Qe from"@effect/platform/FileSystem";import*as Xe from"effect/Chunk";import*as Y from"effect/Effect";import*as _ from"effect/Stream";var se=class extends Y.Service()("@TSDataBuilders/FileContentChecker",{effect:Y.gen(function*(){let o=yield*Qe.FileSystem,c=new TextDecoder;return{check:Y.fnUntraced(function*(f){let{content:d,filePath:a}=f;return yield*Y.logDebug(`[FileContentChecker](${a}): Checking file content`),yield*_.orDie(o.stream(a,{chunkSize:16*1024})).pipe(_.map(g=>c.decode(g,{stream:!0})),_.mapAccum("",(g,T)=>{let u=g+T;return[u.slice(-d.length+1),u.includes(d)]}),_.find(g=>!!g),_.tap(()=>Y.logDebug(`[FileContentChecker](${a}): found expected content`)),_.runCollect,Y.map(g=>g.pipe(Xe.get(0))))})}})}){};import*as et from"effect/Data";import*as q from"effect/Effect";import*as tt from"effect/Stream";import{glob as Ft}from"glob";import*as Se from"effect/Effect";var ce=class extends Se.Service()("@TSDataBuilders/Glob",{succeed:{iterate:o=>Se.sync(()=>Ft.iterate(o.path,{cwd:o.cwd,nodir:!0}))}}){};var de=class extends q.Service()("@TSDataBuilders/TreeWalker",{effect:q.gen(function*(){let o=yield*ce,c=yield*R;return{walk:q.fnUntraced(function*(f){let d=yield*c.cwd;return yield*q.logDebug(`[TreeWalker]: Walking path: ${d}/${f}`),tt.fromAsyncIterable(yield*o.iterate({path:f,cwd:d}),a=>new Pe({cause:a}))})}}),dependencies:[ce.Default]}){},Pe=class extends et.TaggedError("TreeWalkerError"){};var X=class extends M.Service()("@TSDataBuilders/Finder",{effect:M.gen(function*(){let o=yield*se,c=yield*de,{include:f,jsdocTag:d}=yield*L,a=`@${d}`;return{find:M.gen(function*(){yield*M.logDebug("[Finder]: Attempting to find files with builders");let O=yield*(yield*c.walk(f)).pipe(he.mapEffect(g=>o.check({filePath:g,content:a}).pipe(M.map(T=>T.pipe(ye.map(()=>g)))),{concurrency:"unbounded"}),he.runCollect,M.map(ee.filter(g=>ye.isSome(g))),M.map(ee.map(g=>g.value)));return yield*M.logDebug(`[Finder]: Found builders in files: ${O.pipe(ee.toArray).join(", ")}`),O}).pipe(M.catchTag("TreeWalkerError",E=>M.die(E)))}}),dependencies:[de.Default,se.Default]}){};import{Node as Rt,Project as Lt,SyntaxKind as h}from"ts-morph";import*as nt from"@effect/platform/FileSystem";import*as V from"effect/Data";import*as t from"effect/Effect";import*as le from"effect/Either";import*as p from"effect/Match";import*as K from"effect/Option";var Te=class extends t.Service()("@TSDataBuilders/TypeNodeParser",{effect:t.gen(function*(){let{jsdocTag:o,inlineDefaultJsdocTag:c,withNestedBuilders:f}=yield*L,d=yield*z,a=t.fnUntraced(function*(T){let u=T.getJsDocs();for(let s of u){let l=s.getTags().find(S=>S.getTagName()===c);if(l){let S=l.getComment();if(typeof S=="string")return K.some(S.trim())}}return K.none()}),E=t.fnUntraced(function*(T){let{type:u,contextNode:s}=T,n=u.getProperties(),l={};for(let S of n){let P=S.getName(),y=S.getTypeAtLocation(s),N=S.isOptional(),I=s.getProject().createSourceFile(`__temp_${yield*d.generateUuid}.ts`,`type __T = ${y.getText()}`,{overwrite:!0}),w=I.getTypeAliasOrThrow("__T").getTypeNodeOrThrow(),b=yield*t.suspend(()=>g({typeNode:w,optional:N,inlineDefault:K.none()}));l[P]=b,s.getProject().removeSourceFile(I)}return l}),O=t.fnUntraced(function*(T){let{type:u,contextNode:s,optional:n,inlineDefault:l}=T;return!u.isObject()||u.getProperties().length===0?yield*new Fe({raw:u.getText(),kind:s.getKind()}):{kind:"TYPE_LITERAL",metadata:yield*E({type:u,contextNode:s}),inlineDefault:l,optional:n}}),g=T=>t.gen(function*(){let{typeNode:u,optional:s,inlineDefault:n}=T,l=u.getKind(),S=p.value(l).pipe(p.when(p.is(h.StringKeyword),()=>t.succeed({kind:"STRING",inlineDefault:n,optional:s})),p.when(p.is(h.NumberKeyword),()=>t.succeed({kind:"NUMBER",inlineDefault:n,optional:s})),p.when(p.is(h.BooleanKeyword),()=>t.succeed({kind:"BOOLEAN",inlineDefault:n,optional:s})),p.when(p.is(h.UndefinedKeyword),()=>t.succeed({kind:"UNDEFINED",inlineDefault:n,optional:s})),p.when(p.is(h.BigIntKeyword),()=>t.succeed({kind:"BIGINT",inlineDefault:n,optional:s})),p.when(p.is(h.SymbolKeyword),()=>t.succeed({kind:"SYMBOL",inlineDefault:n,optional:s})),p.when(p.is(h.AnyKeyword),()=>t.succeed({kind:"ANY",inlineDefault:n,optional:s})),p.when(p.is(h.UnknownKeyword),()=>t.succeed({kind:"UNKNOWN",inlineDefault:n,optional:s})),p.when(p.is(h.ArrayType),()=>t.succeed({kind:"ARRAY",inlineDefault:n,optional:s})),p.when(p.is(h.LiteralType),()=>{let y=u.asKindOrThrow(h.LiteralType).getLiteral().getText();return y==="null"?t.succeed({kind:"NULL",inlineDefault:n,optional:s}):t.succeed({kind:"LITERAL",inlineDefault:n,literalValue:y,optional:s})}),p.when(p.is(h.TypeLiteral),()=>t.gen(function*(){let N=u.asKindOrThrow(h.TypeLiteral).getMembers(),I=yield*t.reduce(N,{},(w,b)=>t.gen(function*(){if(!b.isKind(h.PropertySignature))return w;let v=b.getTypeNode();if(!v)return w;let Z=b.getNameNode().getText(),W=b.hasQuestionToken(),F=yield*a(b),A=yield*t.suspend(()=>g({typeNode:v,optional:W,inlineDefault:F}));return{...w,[Z]:A}}));return{kind:"TYPE_LITERAL",inlineDefault:n,metadata:I,optional:s}})),p.when(p.is(h.ImportType),()=>t.gen(function*(){let y=u.asKindOrThrow(h.ImportType),N=y.getType(),I=N.getSymbol(),w=N.getText();if(!I)return yield*new Le({raw:w});let b=I.getDeclarations();if(b&&b.length>1)return yield*new Ne({raw:w});let[v]=b;return v?yield*O({type:N,contextNode:y,inlineDefault:n,optional:s}):yield*new Ee({raw:w})})),p.when(p.is(h.TupleType),()=>t.gen(function*(){let N=u.asKindOrThrow(h.TupleType).getElements(),I=yield*t.all(N.map(w=>t.suspend(()=>g({typeNode:w,optional:!1,inlineDefault:K.none()}))),{concurrency:"unbounded"});return{kind:"TUPLE",inlineDefault:n,optional:s,members:I}})),p.when(p.is(h.TypeReference),()=>t.gen(function*(){let y=u.asKindOrThrow(h.TypeReference),N=y.getTypeName().getText();if(N==="Date")return{kind:"DATE",optional:s,inlineDefault:n};if(N==="Array")return{kind:"ARRAY",optional:s,inlineDefault:n};let I=y.getTypeArguments();if(N==="Record"){let[pe,Ue]=I;if(!pe||!Ue)return yield*new te({kind:l,raw:u.getText()});let yt=yield*t.suspend(()=>g({typeNode:pe,optional:!1,inlineDefault:K.none()})),ht=yield*t.suspend(()=>g({typeNode:Ue,optional:!1,inlineDefault:K.none()}));return{kind:"RECORD",keyType:yt,valueType:ht,optional:s,inlineDefault:n}}if(["Pick","Omit","Partial","Required","Readonly","Extract","NonNullable"].includes(N))return yield*O({type:y.getType(),contextNode:y,optional:s,inlineDefault:n});let b=y.getType(),v=b.getText(),Z=b.getAliasSymbol();if(!Z)return yield*O({type:b,contextNode:y,optional:s,inlineDefault:n});let W=Z.getDeclarations();if(W&&W.length>1)return yield*new Ne({raw:v});let[F]=W;if(!F)return yield*new Ee({raw:v});let A=Z?.getJsDocTags().map(pe=>pe.getName()).includes(o);if(!Rt.isTypeAliasDeclaration(F))return yield*new Me;let fe=F.getTypeNode();return fe?!A||!f?yield*t.suspend(()=>g({typeNode:fe,optional:s,inlineDefault:n})):{kind:"BUILDER",name:F.getName(),inlineDefault:n,optional:s}:yield*new te({kind:l,raw:v})})),p.when(p.is(h.UnionType),()=>t.gen(function*(){let y=yield*t.all(u.asKindOrThrow(h.UnionType).getTypeNodes().map(N=>t.suspend(()=>g({typeNode:N,optional:!1,inlineDefault:K.none()}))),{concurrency:"unbounded"});return{kind:"UNION",optional:s,members:y,inlineDefault:n}})),p.when(p.is(h.IntersectionType),()=>t.gen(function*(){let y=u.asKindOrThrow(h.IntersectionType),N=y.getTypeNodes(),I=[h.StringKeyword,h.NumberKeyword,h.BooleanKeyword],w=N.find(W=>I.includes(W.getKind()));if(w&&N.length>1)return{kind:"TYPE_CAST",baseTypeMetadata:yield*t.suspend(()=>g({typeNode:w,optional:!1,inlineDefault:n})),inlineDefault:n,optional:s};let b=y.getType();return b.getProperties().length===0?yield*new te({kind:l,raw:u.getText()}):{kind:"TYPE_LITERAL",metadata:yield*E({type:b,contextNode:y}),inlineDefault:n,optional:s}})),p.option);return K.isNone(S)?yield*new te({kind:l,raw:u.getText()}):yield*S.value});return{generateMetadata:g}}),dependencies:[z.Default]}){},ie=class extends t.Service()("@TSDataBuilders/Parser",{effect:t.gen(function*(){let o=yield*nt.FileSystem,c=yield*Te,{jsdocTag:f}=yield*L;return{generateBuildersMetadata:d=>t.gen(function*(){yield*t.logDebug(`[Parser](${d}): Generating builder metadata`),yield*t.logDebug(`[Parser](${d}): Reading source code`);let a=yield*t.orDie(o.readFileString(d)),E=yield*t.try({try:()=>new Lt().createSourceFile(d,a,{overwrite:!0}).getTypeAliases().filter(n=>n.getJsDocs().flatMap(l=>l.getTags().flatMap(S=>S.getTagName())).includes(f)).map(n=>{let l=n.getName();if(!n.isExported())return le.left(new Ae({typeName:l}));let S=n.getTypeNode();return S?.isKind(h.TypeLiteral)||S?.isKind(h.TypeReference)?le.right({name:n.getName(),node:S}):le.left(new Re({typeName:n.getName()}))}).filter(Boolean),catch:T=>new Be({cause:T})}),O=yield*t.all(E.map(T=>T),{concurrency:"unbounded"});return yield*t.logDebug(`[Parser](${d}): Generating metadata for types: ${O.map(({name:T})=>T).join(", ")}`),yield*t.all(O.map(({name:T,node:u})=>c.generateMetadata({typeNode:u,optional:!1,inlineDefault:K.none()}).pipe(t.tap(()=>t.logDebug(`[Parser](${d}): Finished generating metadata for type: ${T}`)),t.map(s=>({name:T,shape:s,path:d})))),{concurrency:"unbounded"})}).pipe(t.catchTags({ParserError:a=>t.die(a),MissingSymbolDeclarationError:a=>t.dieMessage(`[Parser](${d}): Missing symbol declaration for type: ${a.raw}`),UnsupportedTypeAliasDeclarationError:()=>t.dieMessage(`[Parser](${d}): Unsupported type alias declaration`),MultipleSymbolDeclarationsError:a=>t.dieMessage(`[Parser](${d}): Missing symbol declaration error for type: ${a.raw}`),MissingSymbolError:a=>t.dieMessage(`[Parser](${d}): Missing symbol error for type: ${a.raw}`),UnexportedDatabuilderError:a=>t.dieMessage(`[Parser](${d}): Unexported databuilder ${a.typeName}`),UnsupportedSyntaxKindError:a=>t.dieMessage(`[Parser](${d}): Unsupported syntax kind of id: ${a.kind} for type: ${a.raw}`),CannotBuildTypeReferenceMetadataError:a=>t.dieMessage(`[Parser](${d}): Cannot build type reference metadata with kind of id: ${a.kind} for type: ${a.raw}. Is it a root of databuilder?`),UnsupportedBuilderTypeError:a=>t.dieMessage(`[Parser](${d}): Unsupported builder type ${a.typeName}`)}))}}),dependencies:[Te.Default]}){},te=class extends V.TaggedError("UnsupportedSyntaxKindError"){},Me=class extends V.TaggedError("UnsupportedTypeAliasDeclarationError"){},Fe=class extends V.TaggedError("CannotBuildTypeReferenceMetadataError"){},Be=class extends V.TaggedError("ParserError"){},Ae=class extends V.TaggedError("UnexportedDatabuilderError"){},Re=class extends V.TaggedError("UnsupportedBuilderTypeError"){},Le=class extends V.TaggedError("MissingSymbolError"){},Ee=class extends V.TaggedError("MissingSymbolDeclarationError"){},Ne=class extends V.TaggedError("MultipleSymbolDeclarationsError"){};import*as rt from"effect/Chunk";import*as $ from"effect/Effect";import*as at from"effect/Function";var st=$.gen(function*(){let e=yield*X,o=yield*ie,c=yield*Q;yield*$.logInfo("[TSDatabuilders]: Generating builders for your project.");let f=yield*e.find;yield*$.logInfo(`[TSDatabuilders]: Found builders in ${f.length} file(s).`),yield*$.logDebug("[TSDatabuilders]: Attempting to generate builders metadata");let d=yield*$.all(rt.map(f,a=>o.generateBuildersMetadata(a)),{concurrency:"unbounded"}).pipe($.map(a=>a.flatMap(at.identity)));d.length!==0&&(yield*$.logDebug("[TSDatabuilders]: Attempting to create builders files"),yield*c.create(d),yield*$.logInfo(`[TSDatabuilders]: Created ${d.length} builder(s).`))});var ct="0.0.1-alpha.20";var $t=r.text("jsdoc-tag").pipe(r.withDescription(C.jsdocTag),r.withSchema(G.fields.jsdocTag),r.optional),vt=r.text("inline-default-jsdoc-tag").pipe(r.withDescription(C.inlineDefaultJsdocTag),r.withSchema(G.fields.inlineDefaultJsdocTag),r.optional),jt=r.text("with-nested-builders").pipe(r.withDescription(C.withNestedbuilders),r.withSchema(G.fields.withNestedBuilders),r.optional),Gt=r.text("output-dir").pipe(r.withAlias("o"),r.withDescription(C.outputDir),r.withSchema(G.fields.outputDir),r.optional),_t=r.text("include").pipe(r.withAlias("i"),r.withDescription(C.include),r.withSchema(G.fields.include),r.optional),Kt=r.text("file-case").pipe(r.withDescription(C.fileCase),r.withSchema(G.fields.fileCase),r.optional),Jt=r.text("file-suffix").pipe(r.withDescription(C.fileSuffix),r.withSchema(G.fields.fileSuffix),r.optional),Yt=r.text("builder-suffix").pipe(r.withDescription(C.builderSuffix),r.withSchema(G.fields.builderSuffix),r.optional),Wt=r.text("default-string").pipe(r.withDescription(C.defaultString),r.withSchema(G.fields.defaultString),r.optional),Vt=r.text("default-number").pipe(r.withDescription(C.defaultNumber),r.withSchema(G.fields.defaultNumber),r.optional),Zt=r.text("default-boolean").pipe(r.withDescription(C.defaultBoolean),r.withSchema(G.fields.defaultBoolean),r.optional),dt={jsdocTag:$t,outputDir:Gt,withNestedBuilders:jt,include:_t,fileSuffix:Jt,fileCase:Kt,builderSuffix:Yt,defaultString:Wt,defaultNumber:Vt,defaultBoolean:Zt,inlineDefaultJsdocTag:vt},zt=J.make("init",dt).pipe(J.withHandler(He)),qt=J.make("ts-databuilders",dt),lt=qt.pipe(J.withHandler(()=>st),J.withSubcommands([zt]),J.provide(e=>ne.mergeAll(X.Default,ie.Default,Q.Default).pipe(ne.provide(ne.effect(L,_e(e))))),J.run({name:"Typescript Databuilders generator",version:ct}));var Ht=mt.mergeAll(gt.minimumLogLevel(St.Info),R.Default,ft.layer);lt(process.argv).pipe(ut.provide(Ht),pt.runMain);

package/package.json

@@ -1,6 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nemmtor/ts-databuilders",
+  "version": "0.0.1-alpha.20",
   "type": "module",
   "private": false,
   "description": "CLI tool that automatically generates builder classes from annotated TypeScript types.",
@@ -25,37 +26,60 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build:node": "bun build src/main.ts --target node --outfile dist/main.js --production --packages external",
-    "start": "bun --console-depth 10 src/main.ts",
-    "format": "biome format",
-    "format:fix": "biome format --write",
-    "lint": "biome lint",
-    "lint:fix": "biome lint --write",
-    "check-actions": "pnpm exec biome check --formatter-enabled=false --linter-enabled=false",
-    "check-actions:fix": "pnpm exec biome check --formatter-enabled=false --linter-enabled=false --write",
-    "check-types": "tsc -b tsconfig.json",
-    "check-knip": "knip",
-    "check-dep": "depcruise --output-type err-long src"
-  },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.7",
-    "@effect/language-service": "^0.47.3",
+    "@biomejs/biome": "^2.3.2",
+    "@changesets/changelog-github": "^0.5.1",
+    "@changesets/cli": "^2.29.7",
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@commitlint/prompt-cli": "^20.1.0",
+    "@effect/language-service": "^0.58.0",
+    "@effect/vitest": "^0.27.0",
     "@total-typescript/ts-reset": "^0.6.1",
-    "@types/bun": "^1.3.0",
-    "dependency-cruiser": "^17.1.0",
-    "knip": "^5.66.2"
+    "@types/node": "^24.0.0",
+    "@vitest/coverage-v8": "4.0.15",
+    "dependency-cruiser": "^17.2.0",
+    "knip": "^5.66.4",
+    "lefthook": "^2.0.2",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.6",
+    "vitest": "^4.0.6"
   },
   "peerDependencies": {
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@effect/cli": "^0.71.0",
-    "@effect/platform": "^0.92.1",
-    "@effect/platform-node": "^0.98.4",
+    "@effect/cli": "^0.72.0",
+    "@effect/platform": "^0.93.0",
+    "@effect/platform-node": "^0.103.0",
     "effect": "^3.18.4",
-    "glob": "^11.0.3",
+    "glob": "^13.0.0",
     "ts-morph": "^27.0.2"
   },
-  "version": "0.0.1-alpha.2"
-}
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "start": "tsx src/main.ts",
+    "format": "biome format",
+    "format:fix": "biome format --write",
+    "lint": "biome lint",
+    "lint:fix": "biome lint --write",
+    "check-actions": "pnpm exec biome check --formatter-enabled=false --linter-enabled=false",
+    "check-actions:fix": "pnpm exec biome check --formatter-enabled=false --linter-enabled=false --write",
+    "check-types": "tsc -b tsconfig.json",
+    "check-knip": "knip",
+    "check-dep": "depcruise --output-type err-long src",
+    "check-commits": "commitlint",
+    "generate:schema": "tsx scripts/generate-schema.ts",
+    "generate:version": "node scripts/generate-version.mjs",
+    "package:version": "changeset version && pnpm generate:version && git add --all",
+    "package:release": "pnpm build && changeset publish",
+    "postinstall": "pnpm lefthook install",
+    "commit": "commit"
+  }
+}