@nemmtor/ts-databuilders 0.0.1-alpha.1 → 0.0.1-alpha.11

package/README.md

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

package/package.json

@@ -1,6 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nemmtor/ts-databuilders",
+  "version": "0.0.1-alpha.11",
   "type": "module",
   "private": false,
   "description": "CLI tool that automatically generates builder classes from annotated TypeScript types.",
@@ -26,8 +27,11 @@
     "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",
+    "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",
@@ -36,26 +40,36 @@
     "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-dep": "depcruise --output-type err-long src",
+    "gen:schema": "tsx scripts/generate-schema.ts"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.7",
-    "@effect/language-service": "^0.47.3",
+    "@biomejs/biome": "^2.3.2",
+    "@effect/language-service": "^0.55.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.8",
+    "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.100.0",
     "effect": "^3.18.4",
     "glob": "^11.0.3",
     "ts-morph": "^27.0.2"
   },
-  "version": "0.0.1-alpha.1"
+  "packageManager": "pnpm@10.20.0+sha512.cf9998222162dd85864d0a8102e7892e7ba4ceadebbf5a31f9c2fce48dfce317a9c53b9f6464d1ef9042cba2e02ae02a9f7c143a2b438cd93c91840f0192b9dd",
+  "engines": {
+    "node": ">=20.0.0"
+  }
 }