Merge pull request #3247 from hey-api/fix/ts-dsl-object-prop-remove

fix: object ts-dsl improvements, ability to remove

Author: mrlubos

.changeset/big-streets-behave.md

@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+**ts-dsl**: allow removing object properties by passing `null`

.changeset/ready-dots-beg.md

@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+**ts-dsl**: override object properties when called multiple times with the same name

dev/openapi-ts.config.ts

@@ -475,7 +475,7 @@ export default defineConfig(() => {
           // definitions: 'z{{name}}',
           exportFromIndex: true,
           // metadata: true,
-          // name: 'valibot',
+          name: 'valibot',
           // requests: {
           //   case: 'PascalCase',
           //   name: '{{name}}Data',
@@ -524,6 +524,7 @@ export default defineConfig(() => {
               const additional = ctx.nodes.additionalProperties(ctx);
               if (additional === undefined) {
                 const shape = ctx.nodes.shape(ctx);
+                shape.prop('body', $(v).attr('never').call());
                 ctx.nodes.base = () => $(v).attr('looseObject').call(shape);
               }
             },

packages/openapi-ts/src/ts-dsl/expr/object.ts

@@ -21,7 +21,8 @@ const Mixed = AsMixin(
 export class ObjectTsDsl extends Mixed {
   readonly '~dsl' = 'ObjectTsDsl';
 
-  protected _props: Array<ObjectPropTsDsl> = [];
+  protected _props = new Map<string, ObjectPropTsDsl>();
+  protected _spreadCounter = 0;
 
   constructor(...props: Array<ObjectPropTsDsl>) {
     super();
@@ -30,63 +31,101 @@ export class ObjectTsDsl extends Mixed {
 
   override analyze(ctx: AnalysisContext): void {
     super.analyze(ctx);
-    for (const prop of this._props) {
+    for (const prop of this._props.values()) {
       ctx.analyze(prop);
     }
   }
 
-  /** Adds a computed property (e.g. `{ [expr]: value }`). */
-  computed(name: string, expr: ExprFn): this {
-    this._props.push(
-      new ObjectPropTsDsl({ kind: 'computed', name }).value(expr),
-    );
+  /** Returns composite key for the property. */
+  private _propKey(prop: ObjectPropTsDsl): string {
+    if (prop.kind === 'spread') {
+      return `spread:${this._spreadCounter++}`;
+    }
+    return `${prop.kind}:${prop.propName}`;
+  }
+
+  /** Adds a computed property (e.g. `{ [expr]: value }`), or removes if null. */
+  computed(name: string, expr: ExprFn | null): this {
+    if (expr === null) {
+      this._props.delete(`computed:${name}`);
+    } else {
+      this._props.set(
+        `computed:${name}`,
+        new ObjectPropTsDsl({ kind: 'computed', name }).value(expr),
+      );
+    }
     return this;
   }
 
-  /** Adds a getter property (e.g. `{ get foo() { ... } }`). */
-  getter(name: string, stmt: StmtFn): this {
-    this._props.push(new ObjectPropTsDsl({ kind: 'getter', name }).value(stmt));
+  /** Adds a getter property (e.g. `{ get foo() { ... } }`), or removes if null. */
+  getter(name: string, stmt: StmtFn | null): this {
+    if (stmt === null) {
+      this._props.delete(`getter:${name}`);
+    } else {
+      this._props.set(
+        `getter:${name}`,
+        new ObjectPropTsDsl({ kind: 'getter', name }).value(stmt),
+      );
+    }
     return this;
   }
 
   /** Returns true if object has at least one property or spread. */
   hasProps(): boolean {
-    return this._props.length > 0;
+    return this._props.size > 0;
   }
 
   /** Returns true if object has no properties or spreads. */
   get isEmpty(): boolean {
-    return this._props.length === 0;
+    return this._props.size === 0;
   }
 
-  /** Adds a property assignment. */
-  prop(name: string, expr: ExprFn): this {
-    this._props.push(new ObjectPropTsDsl({ kind: 'prop', name }).value(expr));
+  /** Adds a property assignment, or removes if null. */
+  prop(name: string, expr: ExprFn | null): this {
+    if (expr === null) {
+      this._props.delete(`prop:${name}`);
+    } else {
+      this._props.set(
+        `prop:${name}`,
+        new ObjectPropTsDsl({ kind: 'prop', name }).value(expr),
+      );
+    }
     return this;
   }
 
   /** Adds multiple properties. */
   props(...props: ReadonlyArray<ObjectPropTsDsl>): this {
-    this._props.push(...props);
+    for (const prop of props) {
+      this._props.set(this._propKey(prop), prop);
+    }
     return this;
   }
 
-  /** Adds a setter property (e.g. `{ set foo(v) { ... } }`). */
-  setter(name: string, stmt: StmtFn): this {
-    this._props.push(new ObjectPropTsDsl({ kind: 'setter', name }).value(stmt));
+  /** Adds a setter property (e.g. `{ set foo(v) { ... } }`), or removes if null. */
+  setter(name: string, stmt: StmtFn | null): this {
+    if (stmt === null) {
+      this._props.delete(`setter:${name}`);
+    } else {
+      this._props.set(
+        `setter:${name}`,
+        new ObjectPropTsDsl({ kind: 'setter', name }).value(stmt),
+      );
+    }
     return this;
   }
 
   /** Adds a spread property (e.g. `{ ...options }`). */
   spread(expr: ExprFn): this {
-    this._props.push(new ObjectPropTsDsl({ kind: 'spread' }).value(expr));
+    const key = `spread:${this._spreadCounter++}`;
+    this._props.set(key, new ObjectPropTsDsl({ kind: 'spread' }).value(expr));
     return this;
   }
 
   override toAst() {
+    const props = [...this._props.values()];
     const node = ts.factory.createObjectLiteralExpression(
-      this.$node(this._props),
-      this.$multiline(this._props.length),
+      this.$node(props),
+      this.$multiline(props.length),
     );
     return this.$hint(node);
   }

packages/openapi-ts/src/ts-dsl/expr/prop.ts

@@ -12,7 +12,13 @@ import { IdTsDsl } from './id';
 
 type Expr = NodeName | MaybeTsDsl<ts.Expression>;
 type Stmt = NodeName | MaybeTsDsl<ts.Statement>;
-type Kind = 'computed' | 'getter' | 'prop' | 'setter' | 'spread';
+
+export type ObjectPropKind =
+  | 'computed'
+  | 'getter'
+  | 'prop'
+  | 'setter'
+  | 'spread';
 
 type Meta =
   | { kind: 'computed'; name: string }
@@ -27,19 +33,26 @@ export class ObjectPropTsDsl extends Mixed {
   readonly '~dsl' = 'ObjectPropTsDsl';
 
   protected _value?: Ref<Expr | Stmt>;
-  protected meta: Meta;
+  protected _meta: Meta;
 
   constructor(meta: Meta) {
     super();
-    this.meta = meta;
+    this._meta = meta;
+  }
+
+  get kind(): ObjectPropKind {
+    return this._meta.kind;
+  }
+
+  get propName(): string | undefined {
+    return this._meta.name;
   }
 
   override analyze(ctx: AnalysisContext): void {
     super.analyze(ctx);
     ctx.analyze(this._value);
   }
 
-  /** Returns true when all required builder calls are present. */
   get isValid(): boolean {
     return this.missingRequiredCalls().length === 0;
   }
@@ -56,7 +69,7 @@ export class ObjectPropTsDsl extends Mixed {
   override toAst() {
     this.$validate();
     const node = this.$node(this._value);
-    if (this.meta.kind === 'spread') {
+    if (this._meta.kind === 'spread') {
       if (ts.isStatement(node)) {
         throw new Error(
           'Invalid spread: object spread must be an expression, not a statement.',
@@ -65,19 +78,19 @@ export class ObjectPropTsDsl extends Mixed {
       const result = ts.factory.createSpreadAssignment(node);
       return this.$docs(result);
     }
-    if (this.meta.kind === 'getter') {
-      const getter = new GetterTsDsl(this.meta.name).do(node);
+    if (this._meta.kind === 'getter') {
+      const getter = new GetterTsDsl(this._meta.name).do(node);
       const result = this.$node(getter);
       return this.$docs(result);
     }
-    if (this.meta.kind === 'setter') {
-      const setter = new SetterTsDsl(this.meta.name).do(node);
+    if (this._meta.kind === 'setter') {
+      const setter = new SetterTsDsl(this._meta.name).do(node);
       const result = this.$node(setter);
       return this.$docs(result);
     }
-    if (ts.isIdentifier(node) && node.text === this.meta.name) {
+    if (ts.isIdentifier(node) && node.text === this._meta.name) {
       const result = ts.factory.createShorthandPropertyAssignment(
-        this.meta.name,
+        this._meta.name,
       );
       return this.$docs(result);
     }
@@ -87,24 +100,24 @@ export class ObjectPropTsDsl extends Mixed {
       );
     }
     const result = ts.factory.createPropertyAssignment(
-      this.meta.kind === 'computed'
+      this._meta.kind === 'computed'
         ? ts.factory.createComputedPropertyName(
-            this.$node(new IdTsDsl(this.meta.name)),
+            this.$node(new IdTsDsl(this._meta.name)),
           )
-        : this.$node(safePropName(this.meta.name)),
+        : this.$node(safePropName(this._meta.name)),
       node,
     );
     return this.$docs(result);
   }
 
   $validate(): asserts this is this & {
     _value: Expr | Stmt;
-    kind: Kind;
+    kind: ObjectPropKind;
   } {
     const missing = this.missingRequiredCalls();
     if (missing.length === 0) return;
     throw new Error(
-      `Object property${this.meta.name ? ` "${this.meta.name}"` : ''} missing ${missing.join(' and ')}`,
+      `Object property${this._meta.name ? ` "${this._meta.name}"` : ''} missing ${missing.join(' and ')}`,
     );
   }
 

packages/openapi-ts/src/ts-dsl/type/idx-sig.ts

@@ -11,6 +11,7 @@ import { DocMixin } from '../mixins/doc';
 import { ReadonlyMixin } from '../mixins/modifiers';
 
 export type TypeIdxSigType = string | MaybeTsDsl<ts.TypeNode>;
+export type TypeIdxSigKind = 'idxSig';
 
 const Mixed = DocMixin(ReadonlyMixin(TsDsl<ts.IndexSignatureDeclaration>));
 
@@ -27,6 +28,16 @@ export class TypeIdxSigTsDsl extends Mixed {
     fn?.(this);
   }
 
+  /** Element kind. */
+  get kind(): TypeIdxSigKind {
+    return 'idxSig';
+  }
+
+  /** Index signature parameter name. */
+  get propName(): string {
+    return this.name.toString();
+  }
+
   override analyze(ctx: AnalysisContext): void {
     super.analyze(ctx);
     ctx.analyze(this._key);

packages/openapi-ts/src/ts-dsl/type/object.ts

@@ -11,40 +11,58 @@ export class TypeObjectTsDsl extends Mixed {
   readonly '~dsl' = 'TypeObjectTsDsl';
   override scope: NodeScope = 'type';
 
-  protected props: Array<TypePropTsDsl | TypeIdxSigTsDsl> = [];
+  protected _props = new Map<string, TypePropTsDsl | TypeIdxSigTsDsl>();
 
   override analyze(ctx: AnalysisContext): void {
     super.analyze(ctx);
-    for (const prop of this.props) {
+    for (const prop of this._props.values()) {
       ctx.analyze(prop);
     }
   }
 
-  /** Returns true if object has at least one property or spread. */
+  /** Returns true if object has at least one property or index signature. */
   hasProps(): boolean {
-    return this.props.length > 0;
+    return this._props.size > 0;
   }
 
-  /** Adds an index signature to the object type. */
-  idxSig(name: string, fn: (i: TypeIdxSigTsDsl) => void): this {
-    const idx = new TypeIdxSigTsDsl(name, fn);
-    this.props.push(idx);
+  /** Adds an index signature to the object type, or removes if fn is null. */
+  idxSig(name: string, fn: ((i: TypeIdxSigTsDsl) => void) | null): this {
+    const key = `idxSig:${name}`;
+    if (fn === null) {
+      this._props.delete(key);
+    } else {
+      this._props.set(key, new TypeIdxSigTsDsl(name, fn));
+    }
     return this;
   }
 
-  /** Returns true if object has no properties or spreads. */
+  /** Returns true if object has no properties or index signatures. */
   get isEmpty(): boolean {
-    return !this.props.length;
+    return this._props.size === 0;
+  }
+
+  /** Adds a property signature, or removes if fn is null. */
+  prop(name: string, fn: ((p: TypePropTsDsl) => void) | null): this {
+    const key = `prop:${name}`;
+    if (fn === null) {
+      this._props.delete(key);
+    } else {
+      this._props.set(key, new TypePropTsDsl(name, fn));
+    }
+    return this;
   }
 
-  /** Adds a property signature (returns property builder). */
-  prop(name: string, fn: (p: TypePropTsDsl) => void): this {
-    const prop = new TypePropTsDsl(name, fn);
-    this.props.push(prop);
+  /** Adds multiple properties/index signatures. */
+  props(...members: ReadonlyArray<TypePropTsDsl | TypeIdxSigTsDsl>): this {
+    for (const member of members) {
+      this._props.set(`${member.kind}:${member.propName}`, member);
+    }
     return this;
   }
 
   override toAst() {
-    return ts.factory.createTypeLiteralNode(this.$node(this.props));
+    return ts.factory.createTypeLiteralNode(
+      this.$node([...this._props.values()]),
+    );
   }
 }

packages/openapi-ts/src/ts-dsl/type/prop.ts

@@ -16,6 +16,7 @@ import { TokenTsDsl } from '../token';
 import { safePropName } from '../utils/name';
 
 export type TypePropType = NodeName | MaybeTsDsl<ts.TypeNode>;
+export type TypePropKind = 'prop';
 
 const Mixed = DocMixin(OptionalMixin(ReadonlyMixin(TsDsl<ts.TypeElement>)));
 
@@ -31,6 +32,16 @@ export class TypePropTsDsl extends Mixed {
     fn(this);
   }
 
+  /** Element kind. */
+  get kind(): TypePropKind {
+    return 'prop';
+  }
+
+  /** Property name. */
+  get propName(): string {
+    return this.name.toString();
+  }
+
   override analyze(ctx: AnalysisContext): void {
     super.analyze(ctx);
     ctx.analyze(this._type);