@nemmtor/ts-databuilders 0.0.1-alpha.0 → 0.0.1-alpha.10

package/README.md

@@ -1,14 +1,458 @@
 # 🧱 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
+All configuration is optional with sensible defaults.
+
+### Initialize Config File (optional)
+Generate a default `ts-databuilders.json` configuration file:
+```bash
+pnpm ts-databuilders init
+```
+You can also generate configuration file by providing values step by step in an interactive wizard:
+```bash
+pnpm ts-databuilders init --wizard
+```
+
+### Configure via CLI flags (optional):
+```bash
+pnpm ts-databuilders --output-dir="src/__generated__" --jsdoc-tag=MyBuilder
+```
+You can also provide configuration by going through interactive wizard:
+```bash
+pnpm ts-databuilders --wizard
+```
+
+### Options Reference
+
+| Name          | Flag                                                  | 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`        |
+| 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
+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
+
+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/package.json

@@ -1,6 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@nemmtor/ts-databuilders",
+  "version": "0.0.1-alpha.10",
   "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.7",
+    "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.0"
+  "packageManager": "pnpm@10.20.0+sha512.cf9998222162dd85864d0a8102e7892e7ba4ceadebbf5a31f9c2fce48dfce317a9c53b9f6464d1ef9042cba2e02ae02a9f7c143a2b438cd93c91840f0192b9dd",
+  "engines": {
+    "node": ">=20.0.0"
+  }
 }

package/dist/main.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-import*as Se from"@effect/platform-node/NodeContext";import*as Re from"@effect/platform-node/NodeRuntime";import{Effect as Ve}from"effect";import*as R from"@effect/cli/Command";import*as G from"effect/Layer";import*as le from"@effect/platform/FileSystem";import*as L from"effect/Effect";import*as oe from"effect/Context";import*as I from"effect/Schema";var ae={string:"",number:0,boolean:!1},ie=I.Struct({string:I.String,number:I.NumberFromString,boolean:I.BooleanFromString});class k extends oe.Tag("Configuration")(){}import Z from"node:path";import*as me from"@effect/platform/FileSystem";import*as w from"effect/Effect";import*as T from"effect/Match";import{Project as Pe}from"ts-morph";var q=(r)=>r.replace(/([a-z0-9])([A-Z])/g,"$1-$2").replace(/([A-Z])([A-Z][a-z])/g,"$1-$2").replace(/_/g,"-").toLowerCase(),te=(r)=>{return r.split(/[-_\s]+/).flatMap((n)=>n.split(/(?=[A-Z])/)).filter(Boolean).map((n)=>n.charAt(0).toUpperCase()+n.slice(1).toLowerCase()).join("")},re=(r)=>{return r.split(/[-_\s]+/).flatMap((m)=>m.split(/(?=[A-Z])/)).filter(Boolean).map((m,e)=>{let o=m.toLowerCase();return e===0?o:o.charAt(0).toUpperCase()+o.slice(1)}).join("")};var se=(r)=>{let{fieldName:n,optional:m,typeName:e,isNestedBuilder:o}=r,l=n.replaceAll("'","").replaceAll('"',""),h=re(l),i=`with${te(l)}`,t=[`return this.with({ ${n}: ${h} });`],a=[`return this.with({ ${n}: ${h}.build() });`],f=o?a:t,u=[`if (!${h}) {`,`  const { "${l}": _unused, ...rest } = this.build();`,"  return this.with(rest);","}"],C=m?[...u,...f]:f,B=`${e}['${l}']`;return{name:i,isPublic:!0,parameters:[{name:h,type:o?`DataBuilder<${B}>`:B}],statements:C}};class H extends w.Service()("@TSDataBuilders/BuilderGenerator",{effect:w.gen(function*(){let r=yield*me.FileSystem,{outputDir:n,fileSuffix:m,builderSuffix:e,defaults:o}=yield*k,l=(h)=>T.value(h).pipe(T.when({kind:"STRING"},()=>`"${o.string}"`),T.when({kind:"NUMBER"},()=>o.number),T.when({kind:"BOOLEAN"},()=>o.boolean),T.when({kind:"UNDEFINED"},()=>"undefined"),T.when({kind:"DATE"},()=>"new Date()"),T.when({kind:"ARRAY"},()=>"[]"),T.when({kind:"LITERAL"},(i)=>i.literalValue),T.when({kind:"TYPE_CAST"},(i)=>l(i.baseTypeMetadata)),T.when({kind:"TUPLE"},(i)=>{return`[${i.members.map((a)=>l(a)).map((a)=>`${a}`).join(", ")}]`}),T.when({kind:"TYPE_LITERAL"},(i)=>{return`{${Object.entries(i.metadata).filter(([a,{optional:f}])=>!f).map(([a,f])=>`${a}: ${l(f)}`).join(", ")}}`}),T.when({kind:"RECORD"},(i)=>{if(i.keyType.kind==="STRING"||i.keyType.kind==="NUMBER")return"{}";let t=l(i.keyType),a=l(i.valueType);return`{${t}: ${a}}`}),T.when({kind:"UNION"},(i)=>{let a=i.members.slice().sort((f,u)=>{let C=ce.indexOf(f.kind),B=ce.indexOf(u.kind);return(C===-1?1/0:C)-(B===-1?1/0:B)})[0];if(!a)return"never";return l(a)}),T.when({kind:"BUILDER"},(i)=>{return`new ${i.name}${e}().build()`}),T.exhaustive);return{generateBaseBuilder:w.fnUntraced(function*(){let h=Z.resolve(n,"data-builder.ts");yield*r.writeFileString(h,xe)}),generateBuilder:w.fnUntraced(function*(h){let i=new Pe,t=h.name,a=Z.resolve(n,`${q(t)}${m}.ts`),f=i.createSourceFile(a,"",{overwrite:!0}),u=Z.resolve(h.path),C=Z.relative(Z.dirname(a),u).replace(/\.ts$/,"");if(f.addImportDeclaration({namedImports:[t],isTypeOnly:!0,moduleSpecifier:C}),f.addImportDeclaration({namedImports:["DataBuilder"],moduleSpecifier:"./data-builder"}),h.shape.kind!=="TYPE_LITERAL")return yield*w.dieMessage("[BuilderGenerator]: Expected root type to be type literal");[...new Set(Me(h.shape.metadata))].forEach((g)=>{f.addImportDeclaration({namedImports:[`${g}${e}`],moduleSpecifier:`./${q(g)}${m}`})});let M=Object.entries(h.shape.metadata).filter(([g,{optional:b}])=>!b).map(([g,b])=>`${g}: ${b.kind==="TYPE_CAST"?`${l(b)} as ${t}['${g}']`:l(b)}`),P=Object.entries(h.shape.metadata).map(([g,{optional:b,kind:ee}])=>se({fieldName:g,optional:b,typeName:t,isNestedBuilder:ee==="BUILDER"})),F=`{
-  ${M.join(`,
-  `)}
-}`;f.addClass({name:`${t}${e}`,isExported:!0,extends:`DataBuilder<${t}>`,methods:[{name:"constructor",statements:[`super(${F});`]},...P]}),f.saveSync()})}})}){}var ce=["UNDEFINED","BOOLEAN","NUMBER","STRING","DATE","LITERAL","TYPE_LITERAL","ARRAY","TUPLE","RECORD"],xe=`export abstract class DataBuilder<T> {
-  private data: T;
-
-  constructor(initialData: T) {
-    this.data = initialData;
-  }
-
-  public build(): Readonly<T> {
-    return structuredClone(this.data);
-  }
-
-  protected with(partial: Partial<T>): this {
-    this.data = { ...this.data, ...partial };
-    return this;
-  }
-}
-`;function Me(r){let n=[];function m(e){switch(e.kind){case"BUILDER":n.push(e.name);break;case"TYPE_LITERAL":Object.values(e.metadata).forEach(m);break;case"UNION":case"TUPLE":e.members.forEach(m);break;case"RECORD":m(e.keyType),m(e.valueType);break}}return Object.values(r).forEach(m),n}class O extends L.Service()("@TSDataBuilders/Builders",{effect:L.gen(function*(){let r=yield*le.FileSystem,n=yield*H,{outputDir:m}=yield*k;return{create:L.fnUntraced(function*(e){if(yield*r.exists(m))yield*r.remove(m,{recursive:!0});yield*r.makeDirectory(m,{recursive:!0}),yield*n.generateBaseBuilder(),yield*L.all(e.map((l)=>n.generateBuilder(l)),{concurrency:"unbounded"})})}}),dependencies:[H.Default]}){}import*as s from"@effect/cli/Options";import*as N from"effect/HashMap";import*as J from"effect/Option";import*as $ from"effect/Schema";var Oe=s.text("jsdocTag").pipe(s.withDescription("JSDoc tag used to mark types for data building generation."),s.withSchema($.NonEmptyTrimmedString),s.withDefault("DataBuilder")),Ne=s.text("output-dir").pipe(s.withAlias("o"),s.withDescription("Output directory for generated builders."),s.withSchema($.NonEmptyTrimmedString),s.withDefault("generated/builders")),_e=s.text("include").pipe(s.withAlias("i"),s.withDescription("Glob pattern for files included while searching for jsdoc tag."),s.withSchema($.NonEmptyTrimmedString),s.withDefault("src/**/*.ts{,x}")),Ae=s.text("file-suffix").pipe(s.withDescription("File suffix for created builder files."),s.withSchema($.NonEmptyTrimmedString),s.withDefault(".builder")),Ue=s.text("builder-suffix").pipe(s.withDescription("Suffix for generated classes."),s.withSchema($.NonEmptyTrimmedString),s.withDefault("Builder")),je=s.keyValueMap("defaults").pipe(s.withDescription("Default values to be used in data builder constructor."),s.withSchema($.HashMapFromSelf({key:$.Literal("string","number","boolean"),value:$.String}).pipe($.transform(ie,{decode:(r)=>{return{string:r.pipe(N.get("string"),J.getOrElse(()=>"")),number:r.pipe(N.get("number"),J.getOrElse(()=>"0")),boolean:r.pipe(N.get("boolean"),J.getOrElse(()=>"false"))}},encode:(r)=>{return N.make(["string",r.string],["number",r.number],["boolean",r.boolean])},strict:!1}))),s.withDefault(ae)),fe={jsdocTag:Oe,outputDir:Ne,include:_e,fileSuffix:Ae,builderSuffix:Ue,defaults:je};import*as x from"effect/Chunk";import*as D from"effect/Effect";import*as he from"effect/Function";import*as U from"effect/Option";import*as X from"effect/Stream";import*as ue from"effect/Data";import*as de from"effect/Effect";import*as pe from"effect/Stream";import{glob as We}from"glob";class _ extends de.Service()("@TSDataBuilders/TreeWalker",{succeed:{walk:(r)=>{return pe.fromAsyncIterable(We.stream(r,{cwd:".",nodir:!0}),(n)=>new ne({cause:n}))}}}){}class ne extends ue.TaggedError("TreeWalkerError"){}import{FileSystem as Ye}from"@effect/platform";import*as A from"effect/Effect";import*as S from"effect/Stream";class Q extends A.Service()("@TSDataBuilders/FileContentChecker",{effect:A.gen(function*(){let r=yield*Ye.FileSystem,n=new TextDecoder;return{check:A.fnUntraced(function*(m){let{content:e,filePath:o}=m;return yield*r.stream(o,{chunkSize:16384}).pipe(S.map((i)=>n.decode(i,{stream:!0})),S.mapAccum("",(i,t)=>{let a=i+t;return[a.slice(-e.length+1),a.includes(e)]}),S.find(Boolean),S.runCollect)})}})}){}class j extends D.Service()("@TSDataBuilders/Finder",{effect:D.gen(function*(){let r=yield*Q,{include:n,jsdocTag:m}=yield*k,e=`@${m}`;return{find:D.fnUntraced(function*(){return yield*(yield*_).walk(n).pipe(X.mapEffect((i)=>r.check({filePath:i,content:e}).pipe(D.map(x.map((t)=>t?U.some(i):U.none()))),{concurrency:"unbounded"}),X.runCollect,D.map(x.flatMap(he.identity)),D.map(x.filter((i)=>U.isSome(i))),D.map(x.map((i)=>i.value)))})}}),dependencies:[Q.Default]}){}import*as ke from"@effect/platform/FileSystem";import*as V from"effect/Data";import*as p from"effect/Effect";import*as z from"effect/Either";import{Project as Ze,SyntaxKind as ve}from"ts-morph";import*as v from"effect/Data";import*as c from"effect/Effect";import*as d from"effect/Match";import*as Ce from"effect/Option";import{Node as Ge,SyntaxKind as E}from"ts-morph";class K extends c.Service()("@TSDataBuilders/TypeNodeParser",{effect:c.gen(function*(){let{jsdocTag:r}=yield*k,n=(m)=>c.gen(function*(){let{typeNode:e,optional:o}=m,l=e.getKind(),h=d.value(l).pipe(d.when(d.is(E.StringKeyword),()=>c.succeed({kind:"STRING",optional:o})),d.when(d.is(E.NumberKeyword),()=>c.succeed({kind:"NUMBER",optional:o})),d.when(d.is(E.BooleanKeyword),()=>c.succeed({kind:"BOOLEAN",optional:o})),d.when((t)=>t===E.TypeReference&&e.getText()==="Date",()=>c.succeed({kind:"DATE",optional:o})),d.when((t)=>t===E.UndefinedKeyword,()=>c.succeed({kind:"UNDEFINED",optional:o})),d.when((t)=>t===E.ArrayType,()=>c.succeed({kind:"ARRAY",optional:o})),d.when((t)=>t===E.LiteralType,()=>c.succeed({kind:"LITERAL",literalValue:e.asKindOrThrow(E.LiteralType).getLiteral().getText(),optional:o})),d.when((t)=>t===E.TypeLiteral,()=>c.gen(function*(){let a=e.asKindOrThrow(E.TypeLiteral).getMembers();return{kind:"TYPE_LITERAL",metadata:yield*c.reduce(a,{},(u,C)=>c.gen(function*(){if(!C.isKind(E.PropertySignature))return u;let B=C.getTypeNode();if(!B)return u;let M=C.getNameNode().getText(),P=C.hasQuestionToken(),F=yield*c.suspend(()=>n({typeNode:B,optional:P}));return{...u,[M]:F}})),optional:o}})),d.when(d.is(E.TupleType),()=>c.gen(function*(){let a=e.asKindOrThrow(E.TupleType).getElements(),f=yield*c.all(a.map((u)=>c.suspend(()=>n({typeNode:u,optional:!1}))));return{kind:"TUPLE",optional:o,members:f}})),d.when(d.is(E.TypeReference),()=>c.gen(function*(){let t=e.asKindOrThrow(E.TypeReference),a=t.getTypeName().getText(),f=t.getTypeArguments();if(a==="Record"){let[F,g]=f;if(!F||!g)return yield*new y({kind:l,raw:e.getText()});let b=yield*c.suspend(()=>n({typeNode:F,optional:!1})),ee=yield*c.suspend(()=>n({typeNode:g,optional:!1}));return{kind:"RECORD",keyType:b,valueType:ee,optional:o}}if(a==="Array")return{kind:"ARRAY",optional:o};let u=t.getType().getAliasSymbol();if(!u)return yield*new Te;let C=u.getDeclarations();if(C&&C.length>1)return yield*new Ee;let[B]=C;if(!B)return yield*new Be;let M=u?.getJsDocTags().map((F)=>F.getName()).includes(r);if(!Ge.isTypeAliasDeclaration(B))throw Error("TODO: for non-type-alias declarations (interfaces, etc.)");let P=B.getTypeNode();if(!P)return yield*new y({kind:l,raw:e.getText()});if(!M)return yield*c.suspend(()=>n({typeNode:P,optional:o}));return{kind:"BUILDER",name:B.getName(),optional:o}})),d.when(d.is(E.UnionType),()=>c.gen(function*(){let t=yield*c.all(e.asKindOrThrow(E.UnionType).getTypeNodes().map((a)=>c.suspend(()=>n({typeNode:a,optional:!1}))));return{kind:"UNION",optional:o,members:t}})),d.when(d.is(E.IntersectionType),()=>c.gen(function*(){let a=e.asKindOrThrow(E.IntersectionType).getTypeNodes(),f=[E.StringKeyword,E.NumberKeyword,E.BooleanKeyword],u=a.find((C)=>f.includes(C.getKind()));if(u&&a.length>1)return{kind:"TYPE_CAST",baseTypeMetadata:yield*c.suspend(()=>n({typeNode:u,optional:!1})),optional:o};throw Error("TODO: handle it")})),d.option);if(Ce.isNone(h))return yield*new y({kind:l,raw:e.getText()});return yield*h.value});return{generateMetadata:n}})}){}class y extends v.TaggedError("UnsupportedSyntaxKindError"){}class Ee extends v.TaggedError("MultipleSymbolDeclarationsError"){}class Be extends v.TaggedError("MissingSymbolDeclarationError"){}class Te extends v.TaggedError("MissingSymbolError"){}class W extends p.Service()("@TSDataBuilders/Parser",{effect:p.gen(function*(){let r=yield*ke.FileSystem,n=yield*K,{jsdocTag:m}=yield*k;return{generateBuildersMetadata:p.fnUntraced(function*(e){let o=yield*r.readFileString(e),l=yield*p.try({try:()=>{return new Ze().createSourceFile(e,o,{overwrite:!0}).getTypeAliases().filter((u)=>u.getJsDocs().flatMap((C)=>C.getTags().flatMap((B)=>B.getTagName())).includes(m)).map((u)=>{let C=u.getName();if(!u.isExported())return z.left(new ge({path:e,typeName:C}));let B=u.getTypeNode();if(!B||!B.isKind(ve.TypeLiteral))return z.left(new De({path:e,typeName:u.getName()}));return z.right({name:u.getName(),node:B})}).filter(Boolean)},catch:(t)=>new $e({cause:t})}),h=yield*p.all(l.map((t)=>t));return yield*p.all(h.map(({name:t,node:a})=>n.generateMetadata({typeNode:a,optional:!1}).pipe(p.map((f)=>({name:t,shape:f,path:e})),p.catchTag("UnsupportedSyntaxKindError",(f)=>p.fail(new be({kind:f.kind,raw:f.raw,path:e,typeName:t}))))))},p.catchTags({ParserError:(e)=>p.die(e),UnexportedDatabuilderError:(e)=>p.dieMessage(`[Parser]: Unexported databuilder ${e.typeName} at ${e.path}`),RichUnsupportedSyntaxKindError:(e)=>p.dieMessage(`[Parser]: Unsupported syntax kind of id: ${e.kind} with raw type: ${e.raw} found in type ${e.typeName} in file ${e.path}`),UnsupportedBuilderTypeError:(e)=>p.dieMessage(`[Parser]: Unsupported builder type ${e.typeName} in file ${e.path}.`)}))}}),dependencies:[K.Default]}){}class $e extends V.TaggedError("ParserError"){}class ge extends V.TaggedError("UnexportedDatabuilderError"){}class De extends V.TaggedError("UnsupportedBuilderTypeError"){}class be extends V.TaggedError("RichUnsupportedSyntaxKindError"){}import*as we from"effect/Chunk";import*as Y from"effect/Effect";import*as Fe from"effect/Function";var Ie=Y.gen(function*(){let r=yield*j,n=yield*W,m=yield*O,e=yield*r.find(),o=yield*Y.all(we.map(e,(l)=>n.generateBuildersMetadata(l)),{concurrency:"unbounded"}).pipe(Y.map((l)=>l.flatMap(Fe.identity)));if(o.length===0)return;yield*m.create(o)});var ze=R.make("ts-databuilders",fe),Le=ze.pipe(R.withHandler(()=>Ie),R.provide((r)=>G.mergeAll(j.Default,W.Default,O.Default,_.Default).pipe(G.provide(G.succeed(k,k.of(r))))),R.run({name:"Typescript Databuilders generator",version:"v0.0.1"}));Le(process.argv).pipe(Ve.provide(Se.layer),Re.runMain);