aws-sdk#AWSError TypeScript Examples

export async function get(id: string) {
  try {
    const objectParams = {
      Key: id,
      Bucket: BUCKET_NAME,
    };
    const data = await s3.getObject(objectParams).promise();
    return data.Body;
  } catch (error: unknown) {
    if ((error as AWSError)?.code === 'NoSuchKey') {
      return null;
    }
    throw error;
  }
}

constructor(error: AWSError, public tableClass?: ITable<any>, public queryInput?: any) {
    super(error.message)
    Object.assign(this, error)
    Error.captureStackTrace(this, this.constructor)
    this.name = error.name
    if (tableClass != null) {
      this.tableName = tableClass.schema.name
    }
  }

@handlerEvent(Action.Delete)
    @commonAws({ serviceName: 'CodeCommit', debug: true })
    public async delete(action: Action, args: HandlerArgs<ResourceModel>, service: CodeCommit, model: ResourceModel): Promise<null> {
        const { awsAccountId, logicalResourceIdentifier, region } = args.request;
        let { arn, id, name } = model;
        if (!arn && !id && !name) {
            throw new exceptions.NotFound(this.typeName, logicalResourceIdentifier);
        }
        if (!arn) {
            arn = Resource.formatArn(region, awsAccountId, id);
        }
        if (!id) {
            id = Resource.extractResourceId(arn);
        }
        const rules = await this.listRuleTemplates(service, args.logger, { id, name }).catch((err: AWSError) => {
            if (err?.code === 'ApprovalRuleTemplateDoesNotExistException') {
                throw new exceptions.NotFound(this.typeName, id || logicalResourceIdentifier);
            } else {
                // Raise the original exception
                throw err;
            }
        });
        if (!rules.length) {
            throw new exceptions.NotFound(this.typeName, id || logicalResourceIdentifier);
        }
        name = rules[0].name;

        const request: CodeCommit.DeleteApprovalRuleTemplateInput = {
            approvalRuleTemplateName: name,
        };

        args.logger.log({ action, message: 'before invoke deleteApprovalRuleTemplate', request });
        const response = await service.deleteApprovalRuleTemplate(request).promise();
        args.logger.log({ action, message: 'after invoke deleteApprovalRuleTemplate', response });

        args.logger.log({ action, message: 'done' });

        return Promise.resolve(null);
    }

private async checkBatchResponse(response: CodeCommitBatchResponse, logger: Logger): Promise<CodeCommitBatchResponse> {
        if (response.errors?.length) {
            logger.log(response.errors);
            const err = Error(response.errors[0].errorMessage) as AWSError;
            err.requestId = response.$response?.requestId;
            err.code = response.errors[0].errorCode;
            throw err;
        }

        return response;
    }

getSecretValue = (secretsManagerClient: SecretsManager, secretName: string):
  Promise<PromiseResult<GetSecretValueResponse, AWSError>> => {
  core.debug(`Fetching '${secretName}'`)
  return secretsManagerClient.getSecretValue({ SecretId: secretName }).promise()
}

private isConnError(err: AWSError): boolean {
        return err.statusCode === 403 || err.code === 'CredentialsError' || err.code === 'UnknownEndpoint';
    }

private extendAwsClient<
        S extends Service = Service,
        C extends Constructor<S> = Constructor<S>,
        O extends ServiceProperties<S, C> = ServiceProperties<S, C>,
        E extends Error = AWSError,
        N extends ServiceOperation<S, C, O, E> = ServiceOperation<S, C, O, E>
    >(
        service: S,
        options?: ServiceConfigurationOptions,
        workerPool?: AwsTaskWorkerPool
    ): ExtendedClient<S> {
        const client: ExtendedClient<S> = new Proxy(service, {
            get(obj: ExtendedClient<S>, prop: string) {
                if ('makeRequestPromise' === prop) {
                    // Extend AWS client with promisified make request method
                    // that can be used with worker pool
                    return async (
                        operation: O,
                        input?: OverloadedArguments<N>,
                        headers?: Record<string, string>
                    ): Promise<InferredResult<S, C, O, E, N>> => {
                        if (workerPool && workerPool.runAwsTask) {
                            try {
                                const result = await workerPool.runAwsTask<
                                    S,
                                    C,
                                    O,
                                    E,
                                    N
                                >({
                                    name: obj.serviceIdentifier,
                                    options,
                                    operation,
                                    input,
                                    headers,
                                });
                                return result;
                            } catch (err) {
                                console.log(err);
                            }
                        }
                        const request = obj.makeRequest(operation as string, input);
                        const headerEntries = Object.entries(headers || {});
                        if (headerEntries.length) {
                            request.on('build', () => {
                                for (const [key, value] of headerEntries) {
                                    request.httpRequest.headers[key] = value;
                                }
                            });
                        }
                        return await request.promise();
                    };
                }
                return obj[prop];
            },
        });
        if (client.config && client.config.update) {
            client.config.update(options);
        }
        return client;
    }

fromAwsError = <R>(error: AWSError): Result<R> => {
  return failure(error.message);
}

error = (err: AWSError, res: NextApiResponse) => {
  console.log(err);
  res.json({ success: false, error: true });
}

error = (_: AWSError, res: NextApiResponse) => {
  res.json({ success: false, error: true });
}