betterddb 0.3.0 → 0.4.1

package/lib/builders/query-builder.d.ts

@@ -1,5 +1,6 @@
 import { BetterDDB } from '../betterddb';
-export declare class QueryBuilder<T> {
+import { z } from 'zod';
+export declare class QueryBuilder<S extends z.ZodType<any>> {
     private parent;
     private key;
     private filters;
@@ -10,18 +11,18 @@ export declare class QueryBuilder<T> {
     private limit?;
     private lastKey?;
     private ascending;
-    constructor(parent: BetterDDB<T>, key: Partial<T>);
+    constructor(parent: BetterDDB<S>, key: Partial<S>);
     usingIndex(indexName: string): this;
     sortAscending(): this;
     sortDescending(): this;
-    where(attribute: keyof T, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
+    where(attribute: keyof S, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
     limitResults(limit: number): this;
     startFrom(lastKey: Record<string, any>): this;
     /**
      * Executes the query and returns a Promise that resolves with an array of items.
      */
-    execute(): Promise<T[]>;
-    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T[] | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<T[]>;
+    execute(): Promise<S[]>;
+    then<TResult1 = S[], TResult2 = never>(onfulfilled?: ((value: S[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<S[] | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<S[]>;
 }

package/lib/builders/query-builder.js

@@ -90,7 +90,7 @@ class QueryBuilder {
             params.FilterExpression = this.filters.join(' AND ');
         }
         const result = await this.parent.getClient().query(params).promise();
-        return (result.Items || []).map(item => this.parent.getSchema().parse(item));
+        return this.parent.getSchema().array().parse(result.Items);
     }
     // Thenable implementation.
     then(onfulfilled, onrejected) {

package/lib/builders/scan-builder.d.ts

@@ -1,20 +1,21 @@
 import { BetterDDB } from '../betterddb';
-export declare class ScanBuilder<T> {
+import { z } from 'zod';
+export declare class ScanBuilder<S extends z.ZodType<any>> {
     private parent;
     private filters;
     private expressionAttributeNames;
     private expressionAttributeValues;
     private limit?;
     private lastKey?;
-    constructor(parent: BetterDDB<T>);
-    where(attribute: keyof T, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
+    constructor(parent: BetterDDB<S>);
+    where(attribute: keyof S, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
     limitResults(limit: number): this;
     startFrom(lastKey: Record<string, any>): this;
     /**
      * Executes the scan and returns a Promise that resolves with an array of items.
      */
-    execute(): Promise<T[]>;
-    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T[] | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<T[]>;
+    execute(): Promise<S[]>;
+    then<TResult1 = S[], TResult2 = never>(onfulfilled?: ((value: S[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<S[] | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<S[]>;
 }

package/lib/builders/scan-builder.js

@@ -60,7 +60,7 @@ class ScanBuilder {
             params.FilterExpression = this.filters.join(' AND ');
         }
         const result = await this.parent.getClient().scan(params).promise();
-        return (result.Items || []).map(item => this.parent.getSchema().parse(item));
+        return this.parent.getSchema().array().parse(result.Items);
     }
     // Thenable implementation.
     then(onfulfilled, onrejected) {

package/lib/builders/update-builder.d.ts

@@ -1,17 +1,18 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-export declare class UpdateBuilder<T> {
+import { z } from 'zod';
+export declare class UpdateBuilder<S extends z.ZodType<any>> {
     private parent;
     private key;
     private actions;
     private condition?;
     private expectedVersion?;
     private extraTransactItems;
-    constructor(parent: BetterDDB<T>, key: Partial<T>, expectedVersion?: number);
-    set(attrs: Partial<T>): this;
-    remove(attrs: (keyof T)[]): this;
-    add(attrs: Partial<Record<keyof T, number | Set<any>>>): this;
-    delete(attrs: Partial<Record<keyof T, Set<any>>>): this;
+    constructor(parent: BetterDDB<S>, key: Partial<S>, expectedVersion?: number);
+    set(attrs: Partial<S>): this;
+    remove(attrs: (keyof S)[]): this;
+    add(attrs: Partial<Record<keyof S, number | Set<any>>>): this;
+    delete(attrs: Partial<Record<keyof S, Set<any>>>): this;
     /**
      * Adds a condition expression to the update.
      */
@@ -31,5 +32,5 @@ export declare class UpdateBuilder<T> {
     /**
      * Commits the update immediately by calling the parent's update method.
      */
-    execute(): Promise<T>;
+    execute(): Promise<S>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "betterddb",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "A definition-based DynamoDB wrapper library that provides a schema-driven and fully typesafe DAL.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/betterddb.ts

@@ -1,5 +1,4 @@
-// src/dynamo-dal.ts
-import { z, ZodSchema } from 'zod';
+import { z } from 'zod';
 import { DynamoDB } from 'aws-sdk';
 import { QueryBuilder } from './builders/query-builder';
 import { ScanBuilder } from './builders/scan-builder';
@@ -8,117 +7,79 @@ import { CreateBuilder } from './builders/create-builder';
 import { GetBuilder } from './builders/get-builder';
 import { DeleteBuilder } from './builders/delete-builder';
 
+export type SchemaType<S extends z.ZodType<any>> = z.infer<S>;
+
 export type PrimaryKeyValue = string | number;
 
-/**
- * A key definition can be either a simple key (a property name)
- * or an object containing a build function that computes the value.
- * (In this design, the attribute name is provided separately.)
- */
-export type KeyDefinition<T> =
-  | keyof T
+export type KeyDefinition<S extends z.ZodType<any>> =
+  | keyof SchemaType<S>
   | {
-      build: (rawKey: Partial<T>) => string;
+      build: (rawKey: Partial<SchemaType<S>>) => string;
     };
 
-/**
- * Configuration for a primary (partition) key.
- */
-export interface PrimaryKeyConfig<T> {
-  /** The attribute name for the primary key in DynamoDB */
+export interface PrimaryKeyConfig<S extends z.ZodType<any>> {
   name: string;
-  /** How to compute the key value; if a keyof T, then the raw value is used;
-   * if an object, the build function is used.
-   */
-  definition: KeyDefinition<T>;
+  definition: KeyDefinition<S>;
 }
 
-/**
- * Configuration for a sort key.
- */
-export interface SortKeyConfig<T> {
-  /** The attribute name for the sort key in DynamoDB */
+export interface SortKeyConfig<S extends z.ZodType<any>> {
   name: string;
-  /** How to compute the sort key value */
-  definition: KeyDefinition<T>;
+  definition: KeyDefinition<S>;
 }
 
-/**
- * Configuration for a Global Secondary Index (GSI).
- */
-export interface GSIConfig<T> {
-  /** The name of the GSI in DynamoDB */
+export interface GSIConfig<S extends z.ZodType<any>> {
   name: string;
-  /** The primary key configuration for the GSI */
-  primary: PrimaryKeyConfig<T>;
-  /** The sort key configuration for the GSI, if any */
-  sort?: SortKeyConfig<T>;
+  primary: PrimaryKeyConfig<S>;
+  sort?: SortKeyConfig<S>;
 }
 
-/**
- * Keys configuration for the table.
- */
-export interface KeysConfig<T> {
-  primary: PrimaryKeyConfig<T>;
-  sort?: SortKeyConfig<T>;
+export interface KeysConfig<S extends z.ZodType<any>> {
+  primary: PrimaryKeyConfig<S>;
+  sort?: SortKeyConfig<S>;
   gsis?: {
-    [gsiName: string]: GSIConfig<T>;
+    [gsiName: string]: GSIConfig<S>;
   };
 }
 
-/**
- * Options for initializing BetterDDB.
- */
-export interface BetterDDBOptions<T> {
-  schema: ZodSchema<T>;
+export interface BetterDDBOptions<S extends z.ZodType<any>> {
+  schema: S;
   tableName: string;
   entityName: string;
-  keys: KeysConfig<T>;
+  keys: KeysConfig<S>;
   client: DynamoDB.DocumentClient;
-  /**
-   * If true, automatically inject timestamp fields:
-   * - On create, sets both `createdAt` and `updatedAt`
-   * - On update, sets `updatedAt`
-   *
-   * (T should include these fields if enabled.)
-   */
   autoTimestamps?: boolean;
 }
 
-/**
- * BetterDDB is a definition-based DynamoDB wrapper library.
- */
-export class BetterDDB<T> {
-  protected schema: ZodSchema<T>;
+export class BetterDDB<S extends z.ZodType<any>> {
+  protected schema: S;
   protected tableName: string;
   protected entityName: string;
   protected client: DynamoDB.DocumentClient;
-  protected keys: KeysConfig<T>;
+  protected keys: KeysConfig<S>;
   protected autoTimestamps: boolean;
 
-  constructor(options: BetterDDBOptions<T>) {
+  constructor(options: BetterDDBOptions<S>) {
     this.schema = options.schema;
     this.tableName = options.tableName;
     this.entityName = options.entityName.toUpperCase();
-    this.keys = options.keys;
     this.client = options.client;
     this.autoTimestamps = options.autoTimestamps ?? false;
+    this.keys = options.keys;
   }
 
-  public getKeys(): KeysConfig<T> {
+  public getKeys(): KeysConfig<S> {
     return this.keys;
   }
-  
+
   public getTableName(): string {
     return this.tableName;
   }
-  
+
   public getClient(): DynamoDB.DocumentClient {
     return this.client;
   }
-  
-  
-  public getSchema(): ZodSchema<T> {
+
+  public getSchema(): S {
     return this.schema;
   }
 
@@ -126,118 +87,70 @@ export class BetterDDB<T> {
     return this.autoTimestamps;
   }
 
-  // Helper: Retrieve the key value from a KeyDefinition.
-  protected getKeyValue(def: KeyDefinition<T>, rawKey: Partial<T>): string {
+  protected getKeyValue(
+    def: KeyDefinition<S>,
+    rawKey: Partial<SchemaType<S>>
+  ): string {
     if (typeof def === 'string' || typeof def === 'number' || typeof def === 'symbol') {
-      return String(rawKey[def]);
-    } else {
-      return def.build(rawKey);
+      return String(rawKey[def as keyof typeof rawKey]);
     }
+    return def.build(rawKey);
   }
 
-  /**
-   * Build the primary key from a raw key object.
-   */
-  public buildKey(rawKey: Partial<T>): Record<string, any> {
+  public buildKey(rawKey: Partial<SchemaType<S>>): Record<string, any> {
     const keyObj: Record<string, any> = {};
-  
-    // For primary (partition) key:
-    const pkConfig = this.keys.primary;
-    keyObj[pkConfig.name] =
-      (typeof pkConfig.definition === 'string' ||
-       typeof pkConfig.definition === 'number' ||
-       typeof pkConfig.definition === 'symbol')
-        ? String((rawKey as any)[pkConfig.definition])
-        : pkConfig.definition.build(rawKey);
-  
-    // For sort key, if defined:
-    if (this.keys.sort) {
-      const skConfig = this.keys.sort;
-      keyObj[skConfig.name] =
-        (typeof skConfig.definition === 'string' ||
-         typeof skConfig.definition === 'number' ||
-         typeof skConfig.definition === 'symbol')
-          ? String((rawKey as any)[skConfig.definition])
-          : skConfig.definition.build(rawKey);
+    const { primary, sort } = this.keys;
+
+    keyObj[primary.name] = this.getKeyValue(primary.definition, rawKey);
+
+    if (sort) {
+      keyObj[sort.name] = this.getKeyValue(sort.definition, rawKey);
     }
+
     return keyObj;
   }
-  
-  /**
-   * Build index attributes for each defined GSI.
-   */
-  public buildIndexes(rawItem: Partial<T>): Record<string, any> {
+
+  public buildIndexes(rawItem: Partial<SchemaType<S>>): Record<string, any> {
     const indexAttributes: Record<string, any> = {};
+    
     if (this.keys.gsis) {
-      for (const gsiName in this.keys.gsis) {
-        const gsiConfig = this.keys.gsis[gsiName];
-  
-        // Compute primary index attribute.
-        const primaryConfig = gsiConfig.primary;
-        indexAttributes[primaryConfig.name] =
-          (typeof primaryConfig.definition === 'string' ||
-           typeof primaryConfig.definition === 'number' ||
-           typeof primaryConfig.definition === 'symbol')
-            ? String((rawItem as any)[primaryConfig.definition])
-            : primaryConfig.definition.build(rawItem);
-  
-        // Compute sort index attribute if provided.
-        if (gsiConfig.sort) {
-          const sortConfig = gsiConfig.sort;
-          indexAttributes[sortConfig.name] =
-            (typeof sortConfig.definition === 'string' ||
-             typeof sortConfig.definition === 'number' ||
-             typeof sortConfig.definition === 'symbol')
-              ? String((rawItem as any)[sortConfig.definition])
-              : sortConfig.definition.build(rawItem);
+      Object.entries(this.keys.gsis).forEach(([_, gsiConfig]) => {
+        const { primary, sort } = gsiConfig;
+        indexAttributes[primary.name] = this.getKeyValue(primary.definition, rawItem);
+        
+        if (sort) {
+          indexAttributes[sort.name] = this.getKeyValue(sort.definition, rawItem);
         }
-      }
+      });
     }
+    
     return indexAttributes;
   }
-  
-  /**
-   * Create an item:
-   * - Computes primary key and index attributes,
-   * - Optionally injects timestamps,
-   * - Validates the item and writes it to DynamoDB.
-   */
-  public create(item: T): CreateBuilder<T> {
-    return new CreateBuilder<T>(this, item);
+
+  public create(item: SchemaType<S>): CreateBuilder<SchemaType<S>> {
+    return new CreateBuilder<SchemaType<S>>(this, item);
   }
-  
-  /**
-   * Get an item by its primary key.
-   */
-  public get(rawKey: Partial<T>): GetBuilder<T> {
-    return new GetBuilder<T>(this, rawKey);
+
+  public get(rawKey: Partial<SchemaType<S>>): GetBuilder<SchemaType<S>> {
+    return new GetBuilder<SchemaType<S>>(this, rawKey);
   }
 
-  /**
-   * Update an item.
-   */
-  public update(key: Partial<T>, expectedVersion?: number): UpdateBuilder<T> {
-    return new UpdateBuilder<T>(this, key, expectedVersion);
+  public update(
+    key: Partial<SchemaType<S>>,
+    expectedVersion?: number
+  ): UpdateBuilder<SchemaType<S>> {
+    return new UpdateBuilder<SchemaType<S>>(this, key, expectedVersion);
   }
 
-  /**
-   * Delete an item.
-   */
-  public delete(rawKey: Partial<T>): DeleteBuilder<T> {
-    return new DeleteBuilder<T>(this, rawKey);
+  public delete(rawKey: Partial<SchemaType<S>>): DeleteBuilder<SchemaType<S>> {
+    return new DeleteBuilder<SchemaType<S>>(this, rawKey);
   }
 
-  /**
-   * Query items.
-   */
-  public query(key: Partial<T>): QueryBuilder<T> {
-    return new QueryBuilder<T>(this, key);
+  public query(key: Partial<SchemaType<S>>): QueryBuilder<SchemaType<S>> {
+    return new QueryBuilder<SchemaType<S>>(this, key);
   }
 
-  /**
-   * Scan for items.
-   */ 
-  public scan(): ScanBuilder<T> {
-    return new ScanBuilder<T>(this);
+  public scan(): ScanBuilder<SchemaType<S>> {
+    return new ScanBuilder<SchemaType<S>>(this);
   }
-}
+}

package/src/builders/create-builder.ts

@@ -1,12 +1,13 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
+import { z } from 'zod';
 
-export class CreateBuilder<T> {
+export class CreateBuilder<S extends z.ZodType<any>> {
   private extraTransactItems: DynamoDB.DocumentClient.TransactWriteItemList = [];
 
-  constructor(private parent: BetterDDB<T>, private item: T) {}
+  constructor(private parent: BetterDDB<S>, private item: S) {}
 
-  public async execute(): Promise<T> {
+  public async execute(): Promise<S> {
     if (this.extraTransactItems.length > 0) {
       // Build our update transaction item.
       const myTransactItem = this.toTransactPut();
@@ -25,7 +26,7 @@ export class CreateBuilder<T> {
     let item = this.item;
     if (this.parent.getAutoTimestamps()) {
       const now = new Date().toISOString();
-      item = { ...item, createdAt: now, updatedAt: now } as T;
+      item = { ...item, createdAt: now, updatedAt: now } as S;
     }
     // Validate the item using the schema.
     const validated = this.parent.getSchema().parse(item);
@@ -65,18 +66,18 @@ export class CreateBuilder<T> {
     return { Put: putItem };
   }
 
-  public then<TResult1 = T, TResult2 = never>(
-    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+  public then<TResult1 = S, TResult2 = never>(
+    onfulfilled?: ((value: S) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
   ): Promise<TResult1 | TResult2> {
     return this.execute().then(onfulfilled, onrejected);
   }
   public catch<TResult = never>(
     onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-  ): Promise<T | TResult> {
+  ): Promise<S | TResult> {
     return this.execute().catch(onrejected);
   }
-  public finally(onfinally?: (() => void) | null): Promise<T> {
+  public finally(onfinally?: (() => void) | null): Promise<S> {
     return this.execute().finally(onfinally);
   }
 }

package/src/builders/delete-builder.ts

@@ -1,10 +1,11 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
+import { z } from 'zod';
 
-export class DeleteBuilder<T> {
+export class DeleteBuilder<S extends z.ZodType<any>> {
   private condition?: { expression: string; attributeValues: Record<string, any> };
   private extraTransactItems: DynamoDB.DocumentClient.TransactWriteItemList = [];
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
+  constructor(private parent: BetterDDB<S>, private key: Partial<S>) {}
 
   /**
    * Specify a condition expression for the delete operation.

package/src/builders/get-builder.ts

@@ -1,16 +1,17 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
+import { z } from 'zod';
 
-export class GetBuilder<T> {
+export class GetBuilder<S extends z.ZodType<any>> {
   private projectionExpression?: string;
   private expressionAttributeNames: Record<string, string> = {};
   private extraTransactItems: DynamoDB.DocumentClient.TransactGetItemList = [];
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
+  constructor(private parent: BetterDDB<S>, private key: Partial<S>) {}
 
   /**
    * Specify a projection by providing an array of attribute names.
    */
-  public withProjection(attributes: (keyof T)[]): this {
+  public withProjection(attributes: (keyof S)[]): this {
     this.projectionExpression = attributes.map(attr => `#${String(attr)}`).join(', ');
     for (const attr of attributes) {
       this.expressionAttributeNames[`#${String(attr)}`] = String(attr);
@@ -18,7 +19,7 @@ export class GetBuilder<T> {
     return this;
   }
 
-  public async execute(): Promise<T | null> {
+  public async execute(): Promise<S | null> {
     if (this.extraTransactItems.length > 0) {
       // Build our update transaction item.
       const myTransactItem = this.toTransactGet();
@@ -66,18 +67,18 @@ export class GetBuilder<T> {
     return { Get: getItem };
   }
 
-  public then<TResult1 = T | null, TResult2 = never>(
-    onfulfilled?: ((value: T | null) => TResult1 | PromiseLike<TResult1>) | null,
+  public then<TResult1 = S | null, TResult2 = never>(
+    onfulfilled?: ((value: S | null) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
   ): Promise<TResult1 | TResult2> {
     return this.execute().then(onfulfilled, onrejected);
   }
   public catch<TResult = never>(
     onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-  ): Promise<T | null | TResult> {
+  ): Promise<S | null | TResult> {
     return this.execute().catch(onrejected);
   }
-  public finally(onfinally?: (() => void) | null): Promise<T | null> {
+  public finally(onfinally?: (() => void) | null): Promise<S | null> {
     return this.execute().finally(onfinally);
   }
 }

package/src/builders/query-builder.ts

@@ -1,7 +1,8 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
+import { z } from 'zod';
 
-export class QueryBuilder<T> {
+export class QueryBuilder<S extends z.ZodType<any>> {
   private filters: string[] = [];
   private expressionAttributeNames: Record<string, string> = {};
   private expressionAttributeValues: Record<string, any> = {};
@@ -11,7 +12,7 @@ export class QueryBuilder<T> {
   private lastKey?: Record<string, any>;
   private ascending: boolean = true;
 
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
+  constructor(private parent: BetterDDB<S>, private key: Partial<S>) {}
 
   public usingIndex(indexName: string): this {
     this.indexName = indexName;
@@ -29,7 +30,7 @@ export class QueryBuilder<T> {
   }
 
   public where(
-    attribute: keyof T,
+    attribute: keyof S,
     operator: 'eq' | 'begins_with' | 'between',
     values: any | [any, any]
   ): this {
@@ -73,7 +74,7 @@ export class QueryBuilder<T> {
   /**
    * Executes the query and returns a Promise that resolves with an array of items.
    */
-  public async execute(): Promise<T[]> {
+  public async execute(): Promise<S[]> {
     // Build a simple key condition for the partition key.
     const keys = this.parent.getKeys();
     const pkName = keys.primary.name;
@@ -106,22 +107,22 @@ export class QueryBuilder<T> {
     }
 
     const result = await this.parent.getClient().query(params).promise();
-    return (result.Items || []).map(item => this.parent.getSchema().parse(item));
+    return this.parent.getSchema().array().parse(result.Items);
   }
 
   // Thenable implementation.
-  public then<TResult1 = T[], TResult2 = never>(
-    onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null,
+  public then<TResult1 = S[], TResult2 = never>(
+    onfulfilled?: ((value: S[]) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
   ): Promise<TResult1 | TResult2> {
     return this.execute().then(onfulfilled, onrejected);
   }
   public catch<TResult = never>(
     onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-  ): Promise<T[] | TResult> {
+  ): Promise<S[] | TResult> {
     return this.execute().catch(onrejected);
   }
-  public finally(onfinally?: (() => void) | null): Promise<T[]> {
+  public finally(onfinally?: (() => void) | null): Promise<S[]> {
     return this.execute().finally(onfinally);
   }
 }