betterddb 0.4.1 → 0.4.3

package/lib/builders/update-builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateBuilder = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 class UpdateBuilder {
     // Reference to the parent BetterDDB instance and key.
     constructor(parent, key, expectedVersion) {
@@ -170,9 +171,9 @@ class UpdateBuilder {
             const myTransactItem = this.toTransactUpdate();
             // Combine with extra transaction items.
             const allItems = [...this.extraTransactItems, myTransactItem];
-            await this.parent.getClient().transactWrite({
+            await this.parent.getClient().send(new lib_dynamodb_1.TransactWriteCommand({
                 TransactItems: allItems
-            }).promise();
+            }));
             // After transaction, retrieve the updated item.
             const result = await this.parent.get(this.key).execute();
             if (result === null) {
@@ -194,7 +195,7 @@ class UpdateBuilder {
             if (this.condition && this.condition.expression) {
                 params.ConditionExpression = this.condition.expression;
             }
-            const result = await this.parent.getClient().update(params).promise();
+            const result = await this.parent.getClient().send(new lib_dynamodb_1.UpdateCommand(params));
             if (!result.Attributes) {
                 throw new Error('No attributes returned after update');
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "betterddb",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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",
@@ -28,7 +28,8 @@
   "author": "R.R. Wang",
   "license": "MIT",
   "dependencies": {
-    "aws-sdk": "^2.1370.0",
+    "@aws-sdk/lib-dynamodb": "^3.744.0",
+    "@aws-sdk/client-dynamodb": "^3.744.0",
     "zod": "^3.21.4"
   },
   "devDependencies": {

package/src/betterddb.ts

@@ -1,85 +1,123 @@
-import { z } from 'zod';
-import { DynamoDB } from 'aws-sdk';
+import { z, ZodSchema } from 'zod';
 import { QueryBuilder } from './builders/query-builder';
 import { ScanBuilder } from './builders/scan-builder';
 import { UpdateBuilder } from './builders/update-builder';
 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>;
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 
 export type PrimaryKeyValue = string | number;
 
-export type KeyDefinition<S extends z.ZodType<any>> =
-  | keyof SchemaType<S>
+/**
+ * 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
   | {
-      build: (rawKey: Partial<SchemaType<S>>) => string;
+      build: (rawKey: Partial<T>) => string;
     };
 
-export interface PrimaryKeyConfig<S extends z.ZodType<any>> {
+/**
+ * Configuration for a primary (partition) key.
+ */
+export interface PrimaryKeyConfig<T> {
+  /** The attribute name for the primary key in DynamoDB */
   name: string;
-  definition: KeyDefinition<S>;
+  /** 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>;
 }
 
-export interface SortKeyConfig<S extends z.ZodType<any>> {
+/**
+ * Configuration for a sort key.
+ */
+export interface SortKeyConfig<T> {
+  /** The attribute name for the sort key in DynamoDB */
   name: string;
-  definition: KeyDefinition<S>;
+  /** How to compute the sort key value */
+  definition: KeyDefinition<T>;
 }
 
-export interface GSIConfig<S extends z.ZodType<any>> {
+/**
+ * Configuration for a Global Secondary Index (GSI).
+ */
+export interface GSIConfig<T> {
+  /** The name of the GSI in DynamoDB */
   name: string;
-  primary: PrimaryKeyConfig<S>;
-  sort?: SortKeyConfig<S>;
+  /** The primary key configuration for the GSI */
+  primary: PrimaryKeyConfig<T>;
+  /** The sort key configuration for the GSI, if any */
+  sort?: SortKeyConfig<T>;
 }
 
-export interface KeysConfig<S extends z.ZodType<any>> {
-  primary: PrimaryKeyConfig<S>;
-  sort?: SortKeyConfig<S>;
+/**
+ * Keys configuration for the table.
+ */
+export interface KeysConfig<T> {
+  primary: PrimaryKeyConfig<T>;
+  sort?: SortKeyConfig<T>;
   gsis?: {
-    [gsiName: string]: GSIConfig<S>;
+    [gsiName: string]: GSIConfig<T>;
   };
 }
 
-export interface BetterDDBOptions<S extends z.ZodType<any>> {
-  schema: S;
+/**
+ * Options for initializing BetterDDB.
+ */
+export interface BetterDDBOptions<T> {
+  schema: ZodSchema;
   tableName: string;
   entityName: string;
-  keys: KeysConfig<S>;
-  client: DynamoDB.DocumentClient;
+  keys: KeysConfig<T>;
+  client: DynamoDBDocumentClient;
+  /**
+   * 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;
 }
 
-export class BetterDDB<S extends z.ZodType<any>> {
-  protected schema: S;
+/**
+ * BetterDDB is a definition-based DynamoDB wrapper library.
+ */
+export class BetterDDB<T> {
+  protected schema: ZodSchema;
   protected tableName: string;
   protected entityName: string;
-  protected client: DynamoDB.DocumentClient;
-  protected keys: KeysConfig<S>;
+  protected client: DynamoDBDocumentClient;
+  protected keys: KeysConfig<T>;
   protected autoTimestamps: boolean;
 
-  constructor(options: BetterDDBOptions<S>) {
+  constructor(options: BetterDDBOptions<T>) {
     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<S> {
+  public getKeys(): KeysConfig<T> {
     return this.keys;
   }
-
+  
   public getTableName(): string {
     return this.tableName;
   }
-
-  public getClient(): DynamoDB.DocumentClient {
+  
+  public getClient(): DynamoDBDocumentClient {
     return this.client;
   }
-
-  public getSchema(): S {
+  
+  
+  public getSchema(): ZodSchema {
     return this.schema;
   }
 
@@ -87,70 +125,118 @@ export class BetterDDB<S extends z.ZodType<any>> {
     return this.autoTimestamps;
   }
 
-  protected getKeyValue(
-    def: KeyDefinition<S>,
-    rawKey: Partial<SchemaType<S>>
-  ): string {
+  // Helper: Retrieve the key value from a KeyDefinition.
+  protected getKeyValue(def: KeyDefinition<T>, rawKey: Partial<T>): string {
     if (typeof def === 'string' || typeof def === 'number' || typeof def === 'symbol') {
-      return String(rawKey[def as keyof typeof rawKey]);
+      return String(rawKey[def]);
+    } else {
+      return def.build(rawKey);
     }
-    return def.build(rawKey);
   }
 
-  public buildKey(rawKey: Partial<SchemaType<S>>): Record<string, any> {
+  /**
+   * Build the primary key from a raw key object.
+   */
+  public buildKey(rawKey: Partial<T>): Record<string, any> {
     const keyObj: Record<string, any> = {};
-    const { primary, sort } = this.keys;
-
-    keyObj[primary.name] = this.getKeyValue(primary.definition, rawKey);
-
-    if (sort) {
-      keyObj[sort.name] = this.getKeyValue(sort.definition, rawKey);
+  
+    // 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);
     }
-
     return keyObj;
   }
-
-  public buildIndexes(rawItem: Partial<SchemaType<S>>): Record<string, any> {
+  
+  /**
+   * Build index attributes for each defined GSI.
+   */
+  public buildIndexes(rawItem: Partial<T>): Record<string, any> {
     const indexAttributes: Record<string, any> = {};
-    
     if (this.keys.gsis) {
-      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);
+      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);
         }
-      });
+      }
     }
-    
     return indexAttributes;
   }
-
-  public create(item: SchemaType<S>): CreateBuilder<SchemaType<S>> {
-    return new CreateBuilder<SchemaType<S>>(this, item);
+  
+  /**
+   * 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 get(rawKey: Partial<SchemaType<S>>): GetBuilder<SchemaType<S>> {
-    return new GetBuilder<SchemaType<S>>(this, rawKey);
+  
+  /**
+   * Get an item by its primary key.
+   */
+  public get(rawKey: Partial<T>): GetBuilder<T> {
+    return new GetBuilder<T>(this, rawKey);
   }
 
-  public update(
-    key: Partial<SchemaType<S>>,
-    expectedVersion?: number
-  ): UpdateBuilder<SchemaType<S>> {
-    return new UpdateBuilder<SchemaType<S>>(this, key, expectedVersion);
+  /**
+   * Update an item.
+   */
+  public update(key: Partial<T>, expectedVersion?: number): UpdateBuilder<T> {
+    return new UpdateBuilder<T>(this, key, expectedVersion);
   }
 
-  public delete(rawKey: Partial<SchemaType<S>>): DeleteBuilder<SchemaType<S>> {
-    return new DeleteBuilder<SchemaType<S>>(this, rawKey);
+  /**
+   * Delete an item.
+   */
+  public delete(rawKey: Partial<T>): DeleteBuilder<T> {
+    return new DeleteBuilder<T>(this, rawKey);
   }
 
-  public query(key: Partial<SchemaType<S>>): QueryBuilder<SchemaType<S>> {
-    return new QueryBuilder<SchemaType<S>>(this, key);
+  /**
+   * Query items.
+   */
+  public query(key: Partial<T>): QueryBuilder<T> {
+    return new QueryBuilder<T>(this, key);
   }
 
-  public scan(): ScanBuilder<SchemaType<S>> {
-    return new ScanBuilder<SchemaType<S>>(this);
+  /**
+   * Scan for items.
+   */ 
+  public scan(): ScanBuilder<T> {
+    return new ScanBuilder<T>(this);
   }
-}
+}

package/src/builders/create-builder.ts

@@ -1,21 +1,22 @@
-import { DynamoDB } from 'aws-sdk';
+
+import { AttributeValue, Put, TransactWriteItem } from '@aws-sdk/client-dynamodb';
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
+import { PutCommand, TransactWriteCommand } from '@aws-sdk/lib-dynamodb';
 
-export class CreateBuilder<S extends z.ZodType<any>> {
-  private extraTransactItems: DynamoDB.DocumentClient.TransactWriteItemList = [];
+export class CreateBuilder<T> {
+  private extraTransactItems: TransactWriteItem[] = [];
 
-  constructor(private parent: BetterDDB<S>, private item: S) {}
+  constructor(private parent: BetterDDB<T>, private item: T) {}
 
-  public async execute(): Promise<S> {
+  public async execute(): Promise<T> {
     if (this.extraTransactItems.length > 0) {
       // Build our update transaction item.
       const myTransactItem = this.toTransactPut();
       // Combine with extra transaction items.
       const allItems = [...this.extraTransactItems, myTransactItem];
-      await this.parent.getClient().transactWrite({
+      await this.parent.getClient().send(new TransactWriteCommand({
         TransactItems: allItems
-      }).promise();
+      }));
       // After transaction, retrieve the updated item.
       const result = await this.parent.get(this.item).execute();
       if (result === null) {
@@ -26,30 +27,30 @@ export class CreateBuilder<S extends z.ZodType<any>> {
     let item = this.item;
     if (this.parent.getAutoTimestamps()) {
       const now = new Date().toISOString();
-      item = { ...item, createdAt: now, updatedAt: now } as S;
+      item = { ...item, createdAt: now, updatedAt: now } as T;
     }
     // Validate the item using the schema.
     const validated = this.parent.getSchema().parse(item);
     let finalItem = { ...validated };
 
     // Compute and merge primary key.
-    const computedKeys = this.parent.buildKey(validated);
+    const computedKeys = this.parent.buildKey(validated as Partial<T>);
     finalItem = { ...finalItem, ...computedKeys };
 
     // Compute and merge index attributes.
-    const indexAttributes = this.parent.buildIndexes(validated);
+    const indexAttributes = this.parent.buildIndexes(validated as Partial<T>);
     finalItem = { ...finalItem, ...indexAttributes };
 
-    await this.parent.getClient().put({
+    await this.parent.getClient().send(new PutCommand({
       TableName: this.parent.getTableName(),
-      Item: finalItem as DynamoDB.DocumentClient.PutItemInputAttributeMap
-    }).promise();
+      Item: finalItem
+    }));
 
-      return validated;
+      return validated as T;
     }
   }
 
-  public transactWrite(ops: DynamoDB.DocumentClient.TransactWriteItemList | DynamoDB.DocumentClient.TransactWriteItem): this {
+  public transactWrite(ops: TransactWriteItem[] | TransactWriteItem): this {
     if (Array.isArray(ops)) {
       this.extraTransactItems.push(...ops);
     } else {
@@ -58,26 +59,26 @@ export class CreateBuilder<S extends z.ZodType<any>> {
     return this;
   }
 
-  public toTransactPut(): DynamoDB.DocumentClient.TransactWriteItem {
-    const putItem: DynamoDB.DocumentClient.Put = {
+  public toTransactPut(): TransactWriteItem{
+    const putItem: Put = {
       TableName: this.parent.getTableName(),
-      Item: this.item as DynamoDB.DocumentClient.PutItemInputAttributeMap,
+      Item: this.item as Record<string, AttributeValue>,
     };
     return { Put: putItem };
   }
 
-  public then<TResult1 = S, TResult2 = never>(
-    onfulfilled?: ((value: S) => TResult1 | PromiseLike<TResult1>) | null,
+  public then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => 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<S | TResult> {
+  ): Promise<T | TResult> {
     return this.execute().catch(onrejected);
   }
-  public finally(onfinally?: (() => void) | null): Promise<S> {
+  public finally(onfinally?: (() => void) | null): Promise<T> {
     return this.execute().finally(onfinally);
   }
 }

package/src/builders/delete-builder.ts

@@ -1,11 +1,10 @@
-import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-
-export class DeleteBuilder<S extends z.ZodType<any>> {
+import { TransactWriteItem, DeleteItemInput } from '@aws-sdk/client-dynamodb';
+import { TransactWriteCommand, DeleteCommand } from '@aws-sdk/lib-dynamodb';
+export class DeleteBuilder<T> {
   private condition?: { expression: string; attributeValues: Record<string, any> };
-  private extraTransactItems: DynamoDB.DocumentClient.TransactWriteItemList = [];
-  constructor(private parent: BetterDDB<S>, private key: Partial<S>) {}
+  private extraTransactItems: TransactWriteItem[] = [];
+  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
 
   /**
    * Specify a condition expression for the delete operation.
@@ -26,16 +25,16 @@ export class DeleteBuilder<S extends z.ZodType<any>> {
       const myTransactItem = this.toTransactDelete();
       // Combine with extra transaction items.
       const allItems = [...this.extraTransactItems, myTransactItem];
-      await this.parent.getClient().transactWrite({
+      await this.parent.getClient().send(new TransactWriteCommand({
         TransactItems: allItems
-      }).promise();
+      }));
       // After transaction, retrieve the updated item.
       const result = await this.parent.get(this.key).execute();
       if (result === null) {
         throw new Error('Item not found after transaction delete');
       }
     } else {
-    const params: DynamoDB.DocumentClient.DeleteItemInput = {
+    const params: DeleteItemInput = {
       TableName: this.parent.getTableName(),
       Key: this.parent.buildKey(this.key)
     };
@@ -43,11 +42,11 @@ export class DeleteBuilder<S extends z.ZodType<any>> {
       params.ConditionExpression = this.condition.expression;
         params.ExpressionAttributeValues = this.condition.attributeValues;
       }
-      await this.parent.getClient().delete(params).promise();
+      await this.parent.getClient().send(new DeleteCommand(params));
     }
   }
 
-  public transactWrite(ops: DynamoDB.DocumentClient.TransactWriteItemList | DynamoDB.DocumentClient.TransactWriteItem): this {
+  public transactWrite(ops: TransactWriteItem[] | TransactWriteItem): this {
     if (Array.isArray(ops)) {
       this.extraTransactItems.push(...ops);
     } else {
@@ -56,8 +55,8 @@ export class DeleteBuilder<S extends z.ZodType<any>> {
     return this;
   }
 
-  public toTransactDelete(): DynamoDB.DocumentClient.TransactWriteItem {
-    const deleteItem: DynamoDB.DocumentClient.Delete = {
+  public toTransactDelete(): TransactWriteItem {
+    const deleteItem: DeleteItemInput = {
       TableName: this.parent.getTableName(),
       Key: this.parent.buildKey(this.key)
     };

package/src/builders/get-builder.ts

@@ -1,17 +1,16 @@
-import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-
-export class GetBuilder<S extends z.ZodType<any>> {
+import { TransactGetCommand, GetCommand } from '@aws-sdk/lib-dynamodb';
+import { GetItemInput, TransactGetItem } from '@aws-sdk/client-dynamodb';
+export class GetBuilder<T> {
   private projectionExpression?: string;
   private expressionAttributeNames: Record<string, string> = {};
-  private extraTransactItems: DynamoDB.DocumentClient.TransactGetItemList = [];
-  constructor(private parent: BetterDDB<S>, private key: Partial<S>) {}
+  private extraTransactItems: TransactGetItem[] = [];
+  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
 
   /**
    * Specify a projection by providing an array of attribute names.
    */
-  public withProjection(attributes: (keyof S)[]): this {
+  public withProjection(attributes: (keyof T)[]): this {
     this.projectionExpression = attributes.map(attr => `#${String(attr)}`).join(', ');
     for (const attr of attributes) {
       this.expressionAttributeNames[`#${String(attr)}`] = String(attr);
@@ -19,20 +18,20 @@ export class GetBuilder<S extends z.ZodType<any>> {
     return this;
   }
 
-  public async execute(): Promise<S | null> {
+  public async execute(): Promise<T | null> {
     if (this.extraTransactItems.length > 0) {
       // Build our update transaction item.
       const myTransactItem = this.toTransactGet();
       // Combine with extra transaction items.
       const allItems = [...this.extraTransactItems, myTransactItem];
-      await this.parent.getClient().transactGet({
+      await this.parent.getClient().send(new TransactGetCommand({
         TransactItems: allItems
-      }).promise();
+      }));
       // After transaction, retrieve the updated item.
       const result = await this.parent.get(this.key).execute();
       return result;
     } else {
-    const params: DynamoDB.DocumentClient.GetItemInput = {
+    const params: GetItemInput = {
       TableName: this.parent.getTableName(),
       Key: this.parent.buildKey(this.key)
     };
@@ -40,13 +39,13 @@ export class GetBuilder<S extends z.ZodType<any>> {
       params.ProjectionExpression = this.projectionExpression;
       params.ExpressionAttributeNames = this.expressionAttributeNames;
     }
-    const result = await this.parent.getClient().get(params).promise();
+    const result = await this.parent.getClient().send(new GetCommand(params));
     if (!result.Item) return null;
-      return this.parent.getSchema().parse(result.Item);
+      return this.parent.getSchema().parse(result.Item) as T;
     }
   }
 
-  public transactGet(ops: DynamoDB.DocumentClient.TransactGetItemList | DynamoDB.DocumentClient.TransactGetItem): this {
+  public transactGet(ops: TransactGetItem[] | TransactGetItem): this {
     if (Array.isArray(ops)) {
       this.extraTransactItems.push(...ops);
     } else {
@@ -55,8 +54,8 @@ export class GetBuilder<S extends z.ZodType<any>> {
     return this;
   }
 
-  public toTransactGet(): DynamoDB.DocumentClient.TransactGetItem {
-    const getItem: DynamoDB.DocumentClient.Get = {
+  public toTransactGet(): TransactGetItem {
+    const getItem: GetItemInput = {
       TableName: this.parent.getTableName(),
       Key: this.parent.buildKey(this.key)
     };
@@ -67,18 +66,18 @@ export class GetBuilder<S extends z.ZodType<any>> {
     return { Get: getItem };
   }
 
-  public then<TResult1 = S | null, TResult2 = never>(
-    onfulfilled?: ((value: S | null) => TResult1 | PromiseLike<TResult1>) | null,
+  public then<TResult1 = T | null, TResult2 = never>(
+    onfulfilled?: ((value: T | 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<S | null | TResult> {
+  ): Promise<T | null | TResult> {
     return this.execute().catch(onrejected);
   }
-  public finally(onfinally?: (() => void) | null): Promise<S | null> {
+  public finally(onfinally?: (() => void) | null): Promise<T | null> {
     return this.execute().finally(onfinally);
   }
 }