@certik/skynet 0.13.1 → 0.14.0

package/.eslintignore

@@ -0,0 +1 @@
+*.d.ts

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.14.0
+
+- BREAKING: only start one DynamoDB client globally
+- Type: Revisit and fix all existing typescript definition files
+
 ## 0.13.1
 
 - Added: s3 getFileSize (@certik/skynet/s3)

package/abi.d.ts

@@ -1,18 +1,18 @@
 type ContractIO = {
-    name: string;
-    type: string;
-    internalType: string | undefined;
-    components: ContractIO[];
+  name: string;
+  type: string;
+  internalType: string | undefined;
+  components: ContractIO[];
 };
 
 type ABI = {
-    constant: boolean;
-    inputs: ContractIO[];
-    name: string;
-    outputs: ContractIO[];
-    payable: boolean;
-    stateMutability: string;
-    type: string;
+  constant: boolean;
+  inputs: ContractIO[];
+  name: string;
+  outputs: ContractIO[];
+  payable: boolean;
+  stateMutability: string;
+  type: string;
 }[];
 
 export const ERC20: ABI;

package/api.d.ts

@@ -1,14 +1,12 @@
 import { Selector } from "./selector";
+import { Route, Serve } from "./app";
+import express from "express";
 
 export function startApiApp(params: {
-    binaryName: string;
-    name: string;
-    selector: Selector;
-    routes: string[];
-    serve: {
-        port: string | undefined;
-        apiKey: string;
-        prefix: string | undefined;
-    };
-    beforeListen: () => void;
+  binaryName: string;
+  name: string;
+  selector?: Selector;
+  routes: Route[];
+  serve: Serve;
+  beforeListen: (args: { app: ReturnType<typeof express> }) => void;
 }): void;

package/app.d.ts

@@ -1,168 +1,174 @@
 import { ERROR_LEVEL } from "./monitor";
 import { Selector } from "./selector";
+import express from "express";
 
 export type Env = {
-    [key: string]: string | null
-}
+  [key: string]: string | null;
+};
 
 export type Route = {
-    method: "POST" | "PUT" | "PATCH" | "GET" | "POST" | "DELETE" | "OPTIONS";
-    path: string;
-    handler: ({ req, res }: { req: any, res: any }) => Promise<void>;
-    protected: boolean;
-}
+  method?: "get" | "post" | "put" | "delete" | "patch";
+  path: string;
+  middlewares?: ((req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void>)[];
+  handler: (args: { req: express.Request; res: express.Response; [key: string]: any }) => Promise<void>;
+  protected?: boolean;
+};
 
 export type Serve = {
-    prefix: string;
-    port: number;
-    apiKey: string;
-    killTimeout: string;
-    cpu: number;
-    mem: number;
-    instances: number;
-}
+  prefix: string;
+  port: number;
+  apiKey?: string;
+  killTimeout?: string;
+  cpu: number;
+  mem: number;
+  instances?: number;
+};
 
 export type Consume = {
-    func: ({ protocol, messages, verbose }: {
-        protocol: string;
-        messages: any;
-        verbose: boolean;
-    }) => Promise<void>;
-    topic: ({ protocol }: { protocol: string }) => string;
-    maxRetry: number;
-    killTimeout: string;
-    cpu: number;
-    mem: number;
-}
+  func: ({ protocol, messages, verbose }: { protocol: string; messages: any; verbose: boolean }) => Promise<void>;
+  topic: ({ protocol }: { protocol: string }) => string;
+  maxRetry?: number;
+  killTimeout?: string;
+  cpu: number;
+  mem: number;
+};
 
 export type State = {
-    type: string;
-    updateInterval: ({ protocol }: { protocol: string }) => number;
-    getMinId: () => Promise<number>;
-    getMaxId: ({ protocol }: { protocol: string }) => Promise<number>;
-}
+  type: string;
+  updateInterval: ({ protocol }: { protocol: string }) => number;
+  getMinId: () => Promise<number>;
+  getMaxId: ({ protocol }: { protocol: string }) => Promise<number>;
+};
 
 export type Produce = {
-    func: ({ protocol, from, to, verbose, send }: {
-        protocol: string;
-        from: number;
-        to: number;
-        verbose: boolean;
-        send: (items: { id: string, name: string }[]) => Promise<void>;
-    }) => Promise<void>;
-    topic: ({ protocol }) => string;
-    deadLetterTopic: ({ protocol }) => string;
-    batchSize: number;
-    maxRetry: number;
-    killTimeout: string;
-    cpu: number;
-    mem: number;
-}
+  func: ({
+    protocol,
+    from,
+    to,
+    verbose,
+    send,
+  }: {
+    protocol: string;
+    from: number;
+    to: number;
+    verbose: boolean;
+    send: (items: { id: string; name: string }[]) => Promise<void>;
+  }) => Promise<void>;
+  topic: ({ protocol }) => string;
+  deadLetterTopic: ({ protocol }) => string;
+  batchSize: number;
+  maxRetry?: number;
+  killTimeout?: string;
+  cpu: number;
+  mem: number;
+};
+
+export type Schedule = string | ((jobName: string) => string);
 
 export type Check = {
-    func: ({ protocol, state, verbose }: { protocol: string, state: string, verbose: boolean })
-        => ({ type: string, message: string });
-    schedule: string;
-    slackChannel: string;
-    killTimeout: string;
-    cpu: number;
-    mem: number;
-}
+  func: ({ protocol, state, verbose }: { protocol: string; state: string; verbose: boolean }) => {
+    type: string;
+    message: string;
+  };
+  schedule: Schedule;
+  slackChannel: string;
+  killTimeout?: string;
+  cpu: number;
+  mem: number;
+};
 
 export type Build = {
-    func: ({ protocol, from, to, verbose }: { protocol: string, from: number, to: number, verbose: boolean })
-        => void;
-    batchSize: number;
-    schedule: string;
-    killTimeout: string;
-    cpu: number;
-    mem: number;
-}
+  func: ({ protocol, from, to, verbose }: { protocol: string; from: number; to: number; verbose: boolean }) => void;
+  batchSize: number;
+  schedule: Schedule;
+  killTimeout?: string;
+  cpu: number;
+  mem: number;
+};
 
 export type Restart = {
-    attempts: number | undefined;
-    mode: string | undefined;
-    interval: string | undefined;
-    delay: string | undefined
-}
+  attempts: number | undefined;
+  mode: string | undefined;
+  interval: string | undefined;
+  delay: string | undefined;
+};
 
 export type Validate = {
-    func: ({ protocol, from, to, verbose }: { protocol: string, from: number, to: number, verbose: boolean })
-        => void;
-    batchSize: number;
-    schedule: string;
-    killTimeout: string;
-    cpu: number;
-    mem: number;
-}
+  func: ({ protocol, from, to, verbose }: { protocol: string; from: number; to: number; verbose: boolean }) => void;
+  batchSize: number;
+  schedule: Schedule;
+  killTimeout?: string;
+  cpu: number;
+  mem: number;
+};
+
+type BuildWithRestart = Build & { restart: Restart | undefined };
 
-type BuildWithConcurrency = Build | { concurrency: number | undefined };
+type BuildWithConcurrency = Build & { concurrency: number | undefined };
 
-type ValidateWithConcurrency = Validate | { concurrency: number | undefined };
+type ValidateWithConcurrency = Validate & { concurrency: number | undefined };
 
 export const SENSITIVE_VALUE: null;
 
 export { ERROR_LEVEL };
 
 export function every(n: number | undefined): {
-    second: string
-    seconds: string,
-    minute: string,
-    minutes: string,
-    hour: string,
-    hours: string,
-    day: string,
-    days: string,
-    week: string,
-    weeks: string,
-}
+  second: string;
+  seconds: string;
+  minute: string;
+  minutes: string;
+  hour: string;
+  hours: string;
+  day: string;
+  days: string;
+  week: string;
+  weeks: string;
+};
 
 export function api(apiParams: {
-    name: string;
-    routes: Route[];
-    serve: Serve;
-    env: Env | undefined;
-    region: string | undefined;
-    beforeListen: () => void;
+  name: string;
+  routes: Route[];
+  serve: Serve;
+  env: Env | undefined;
+  region: string | undefined;
+  beforeListen: (args: { app: ReturnType<typeof express> }) => void;
 }): () => void;
 
 export function consumer(consumerParams: {
-    name: string;
-    selector: Selector;
-    consume: Consume;
-    check: Check;
-    env: Env | undefined;
-    region: string | undefined;
+  name: string;
+  selector?: Selector;
+  consume: Consume;
+  check?: Check;
+  env: Env | undefined;
+  region: string | undefined;
 }): () => void;
 
 export function producer(producerParams: {
-    name: string;
-    selector: Selector;
-    produce: Produce;
-    check: Check;
-    state: State;
-    env: Env | undefined;
-    region: string | undefined;
+  name: string;
+  selector?: Selector;
+  produce: Produce;
+  check?: Check;
+  state: State;
+  env?: Env;
+  region?: string;
 }): () => void;
 
 export function indexer(indexerParams: {
-    name: string;
-    selector: Selector;
-    state: State;
-    build: Build | { restart: Restart | undefined };
-    validate: Validate;
-    check: Check;
-    env: Env | undefined;
-    region: string | undefined;
+  name: string;
+  selector?: Selector;
+  build: BuildWithRestart;
+  check?: Check;
+  env?: Env;
+  region?: string;
 }): () => void;
 
 export function modeIndexer(modeIndexerParams: {
-    name: string;
-    selector: Selector;
-    state: State;
-    build: BuildWithConcurrency;
-    validate: ValidateWithConcurrency;
-    check: Check;
-    env: Env | undefined;
-    region: string | undefined;
+  name: string;
+  selector?: Selector;
+  state: State;
+  build: BuildWithConcurrency;
+  validate?: ValidateWithConcurrency;
+  check?: Check;
+  env?: Env;
+  region?: string;
 }): () => void;

package/availability.d.ts

@@ -1,11 +1,18 @@
-export function wait(time: number | undefined): Promise<void>;
+export function wait(time: number): Promise<void>;
 export function retry(times: number, verbose: boolean, func: Function): Promise<void>;
-export function exponentialRetry<T>(func: () => Promise<T>, { maxRetry, initialDuration, growFactor, test, verbose }:
-    {
-        maxRetry: number,
-        initialDuration: number | undefined,
-        growFactor: number | undefined,
-        test: (result: T) => boolean,
-        verbose: boolean
-    }
+export function exponentialRetry<T>(
+  func: () => Promise<T>,
+  {
+    maxRetry,
+    initialDuration,
+    growFactor,
+    test,
+    verbose,
+  }: {
+    maxRetry: number;
+    initialDuration?: number;
+    growFactor?: number;
+    test: (result: T) => boolean;
+    verbose?: boolean;
+  },
 ): Promise<T>;

package/const.d.ts

@@ -1,42 +1,43 @@
 type Protocol = {
-    nativeTokenName: string,
-    nativeTokenSymbol: string,
-    nativeTokenDecimals: number,
-    nativeTokenAddress: string,
-    nativeTokenLogo: string,
-    nativeTokenCoinGeckoId: string,
-    nativeTokenCmcId: number,
-    endpoint: string,
-    backupEndpoint?: string,
-    archiveEndpoint?: string,
-    tokenStandard: string,
-    scanApi?: {
-      endpoint: string,
-      key: string,
-    },
-    multiCallProvider?: string,
-    scanUrl?: string,
-}
+  nativeTokenName: string;
+  nativeTokenSymbol: string;
+  nativeTokenDecimals: number;
+  nativeTokenAddress: string;
+  nativeTokenLogo: string;
+  nativeTokenCoinGeckoId: string;
+  nativeTokenCmcId: number;
+  endpoint: string;
+  backupEndpoint?: string;
+  archiveEndpoint?: string;
+  tokenStandard: string;
+  scanApi?: {
+    endpoint: string;
+    key: string;
+  };
+  multiCallProvider?: string;
+  scanUrl?: string;
+};
 
 type TimeIntervals = {
-    MINUTE: number,
-    HOUR: number,
-    DAY: number,
-    WEEK: number,
-    YEAR: number,
-}
+  SECOND: number;
+  MINUTE: number;
+  HOUR: number;
+  DAY: number;
+  WEEK: number;
+  YEAR: number;
+};
 
 export const SKYNET_API_PREFIX: string;
 export const PROTOCOLS: {
-    eth: Protocol,
-    bsc: Protocol,
-    polygon: Protocol,
-    heco: Protocol,
-    avax: Protocol,
-    ftm: Protocol,
-    algo: Protocol
-}
+  eth: Protocol;
+  bsc: Protocol;
+  polygon: Protocol;
+  heco: Protocol;
+  avax: Protocol;
+  ftm: Protocol;
+  algo: Protocol;
+};
 export const TIME: {
-    BY_MS: TimeIntervals,
-    BY_S: TimeIntervals,
-}
+  BY_MS: TimeIntervals;
+  BY_S: TimeIntervals;
+};

package/const.js

@@ -129,6 +129,7 @@ const TIME = {
     YEAR: 1000 * 60 * 60 * 24 * 365,
   },
   BY_S: {
+    SECOND: 1,
     MINUTE: 60,
     HOUR: 60 * 60,
     DAY: 60 * 60 * 24,
@@ -137,8 +138,4 @@ const TIME = {
   },
 };
 
-export {
-  SKYNET_API_PREFIX,
-  PROTOCOLS,
-  TIME,
-};
+export { SKYNET_API_PREFIX, PROTOCOLS, TIME };

package/deploy.d.ts

@@ -4,40 +4,48 @@ import { Env, Selector, Check, Restart } from "./app";
 type Service = {
   prefix: string;
   port: number;
-}
+};
 
 type CreateDeployBaseParams = {
-  binaryName: string,
-  name: string,
-  workingDirectory: string,
-  bin: string | undefined,
-  selector: Selector | undefined,
-  env: Env | undefined,
-  region: string | undefined,
-  type: string | undefined,
-  count: number | undefined,
-  check: Check,
-}
+  binaryName: string;
+  name: string;
+  workingDirectory: string;
+  bin?: string;
+  selector?: Selector;
+  env?: Env;
+  region?: string;
+  check?: Check;
+};
 
 export { getJobName };
 
 export function getNomadAddr(isProduction: boolean): Promise<string | undefined>;
 
-export function createModeDeploy(createModeDeployParams: CreateDeployBaseParams | {
-  deltaSchedule: string,
-  validateSchedule: string,
-  deltaCpu: number,
-  deltaMem: number,
-  rebuildCpu: number,
-  rebuildMem: number,
-  validateCpu: number,
-  validateMem: number,
-}): { deploy: () => void };
+export function createModeDeploy(
+  createModeDeployParams: CreateDeployBaseParams & {
+    deltaSchedule: string;
+    validateSchedule: string;
+    deltaKillTimeout?: number;
+    deltaCpu: number;
+    deltaMem: number;
+    rebuildKillTimeout?: number;
+    rebuildCpu: number;
+    rebuildMem: number;
+    validateKillTimeout?: number;
+    validateCpu?: number;
+    validateMem?: number;
+  },
+): { deploy: () => void };
 
-export function createDeploy(createDeployParams: CreateDeployBaseParams | {
-  schedule: string,
-  restart: Restart | undefined,
-  cpu: number,
-  mem: number,
-  service: Service,
-}): { deploy: () => void };
+export function createDeploy(
+  createDeployParams: CreateDeployBaseParams & {
+    type?: string;
+    count?: number;
+    schedule: string;
+    restart?: Restart;
+    cpu: number;
+    mem: number;
+    killTimeout?: number;
+    service: Service;
+  },
+): { deploy: () => void };

package/dynamodb.d.ts

@@ -1,67 +1,63 @@
-import { DynamoDB } from "aws-sdk";
+import { ScanCommandInput, PutCommandOutput, UpdateCommandOutput } from "@aws-sdk/lib-dynamodb";
 
-type Keys = { [key: string]: any };
+import { CreateTableInput, CreateTableOutput } from "@aws-sdk/client-dynamodb";
 
-type Fields = { [key: string]: any };
+export function getDocClient(forceNew?: boolean): DynamoDBDocumentClient;
 
-export function getDocClient(): DynamoDB.DocumentClient;
-
-export function scanWholeTable(options: DynamoDB.DocumentClient.ScanInput): 
-Promise<{
-    Items: any[];
-    Count: number;
-    ScannedCount: number;
+export function scanWholeTable<T>(options: ScanCommandInput): Promise<{
+  Items: T[];
+  Count: number;
+  ScannedCount: number;
 }>;
 
-export function batchCreateRecords(
-    tableName: string,
-    records: any[],
-    maxWritingCapacity: number,
-    verbose: boolean | undefined
+export function batchCreateRecords<T>(
+  tableName: string,
+  records: T[],
+  maxWritingCapacity: number,
+  verbose?: boolean,
 ): Promise<void>;
 
-export function createRecord(
-    tableName: string,
-    fields: Fields,
-    verbose: boolean | undefined
-): Promise<void>;
+export function createRecord<T>(tableName: string, fields: T, verbose?: boolean): Promise<PutCommandOutput>;
 
-export function getRecordsByKey(
-    tableName: string,
-    keys: Keys,
-    indexName: string
-): Promise<DynamoDB.DocumentClient.ItemList | null | undefined>;
+export function getRecordsByKey<TReturn, TKey>(tableName: string, keys: TKey, indexName: string): Promise<TReturn[]>;
 
-export function getRecordByKey(
-    tableName: string,
-    keys: Keys,
-    indexName: string
-): Promise<DynamoDB.DocumentClient.AttributeMap | null>;
+export function getRecordByKey<TReturn, TKey>(
+  tableName: string,
+  keys: TKey,
+  indexName: string,
+): Promise<TReturn | null>;
 
-export function updateRecordByKey(
-    tableName: string,
-    idKey: Keys,
-    fields: Fields,
-    conditionExpressions: string | undefined,
-    verbose: boolean | undefined
-): Promise<DynamoDB.DocumentClient.AttributeMap | undefined>;
+export function updateRecordByKey<TKey, TField>(
+  tableName: string,
+  idKey: TKey,
+  fields: TField,
+  conditionExpressions?: string,
+  verbose?: boolean,
+): Promise<UpdateCommandOutput["Attributes"] | false>;
 
-export function batchDeleteRecords(
-    tableName: string,
-    keys: Keys
-): Promise<void>;
+export function batchDeleteRecords<T>(tableName: string, keys: T): Promise<void>;
 
 export function deleteRecordsByHashKey(
-    tableName: string, 
-    indexName: string | undefined, 
-    hashKeyValue: string, 
-    verbose: boolean | undefined
+  tableName: string,
+  indexName?: string,
+  hashKeyValue: string,
+  verbose?: boolean,
 ): Promise<number>;
 
 export function createTableIfNotExist(
-    tableName: string,
-    attributeDefinitions: DynamoDB.AttributeDefinitions,
-    keySchema: DynamoDB.KeySchema,
-    options: DynamoDB.DocumentClient.CreateTableInput,
-    verbose: boolean | undefined
-): Promise<void>
+  tableName: string,
+  attributeDefinitions: CreateTableInput["AttributeDefinitions"],
+  keySchema: CreateTableInput["KeySchema"],
+  options?: Partial<CreateTableInput>,
+  verbose?: boolean,
+): Promise<CreateTableOutput>;
+
+export {
+  DynamoDBDocumentClient,
+  ScanCommand,
+  BatchWriteCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  UpdateCommand,
+} from "@aws-sdk/lib-dynamodb";

package/dynamodb.js

@@ -11,12 +11,22 @@ import { DynamoDBClient, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
 import { getAWSSDKConfig } from "./env.js";
 import { wait } from "./availability.js";
 
-function getDynamoDB() {
-  return new DynamoDBClient(getAWSSDKConfig());
+let _dynamoDB;
+
+let _docClient;
+
+function getDynamoDB(forceNew = false) {
+  if (!_dynamoDB || forceNew) {
+    _dynamoDB = new DynamoDBClient(getAWSSDKConfig());
+  }
+  return _dynamoDB;
 }
 
-function getDocClient() {
-  return DynamoDBDocumentClient.from(new DynamoDBClient(getAWSSDKConfig()));
+function getDocClient(forceNew = false) {
+  if (!_docClient || forceNew) {
+    _docClient = DynamoDBDocumentClient.from(getDynamoDB());
+  }
+  return _docClient;
 }
 
 function mergeQueries(q1, q2) {

package/env.d.ts

@@ -2,10 +2,15 @@ export function ensureAndGet<T>(envName: string, defaultValue: T): string | T;
 export function getEnvOrThrow(envName: string): string;
 export function getAWSAccessKeyId(): string | undefined;
 export function getAWSSecretAccessKey(): string | undefined;
+export function getAWSSDKConfig(): {
+  region: string;
+  credentials?: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+};
 export function getAWSRegion(): string;
 export function getEnvironment(): string;
-export function getGetBlockApiKey(): string | undefined;
-export function getAlchemyApiKey(identifier: string): string | undefined;
 export function getNodeRealApiKey(identifier: string): string | undefined;
 export function isProduction(): boolean;
 export function isDev(): boolean;

package/indexer.d.ts

@@ -5,21 +5,23 @@ import { Build, State, Validate } from "./app";
 import { SelectorFlags, Selector } from "./selector";
 
 type CreateIndexerAppBaseParams = {
-    binaryName: string,
-    name: string,
-    selector: Selector | undefined,
-    build: Build,
-    maxRetry: number
-}
+  binaryName: string;
+  name: string;
+  selector?: Selector;
+  build: Build;
+  maxRetry?: number;
+};
 
-export function createModeIndexerApp(createModeIndexerAppParams: {
-    buildBatchSize: number | undefined,
-    buildConcurrency: number | undefined,
-    validate: Validate,
-    validateBatchSize: number | undefined,
-    validateConcurrency: number | undefined,
-    state: State,
-} | CreateIndexerAppBaseParams): { run: () => void };
+export function createModeIndexerApp(
+  createModeIndexerAppParams: {
+    buildBatchSize?: number;
+    buildConcurrency?: number;
+    validate?: Validate;
+    validateBatchSize?: number;
+    validateConcurrency?: number;
+    state: State;
+  } & CreateIndexerAppBaseParams,
+): { run: () => void };
 
 export function createIndexerApp(createModeIndexerAppParams: CreateIndexerAppBaseParams): { run: () => void };
 

package/kafka.d.ts

@@ -1,39 +1,31 @@
 import { KafkaMessage } from "kafkajs";
-import { Producer, State } from "./app";
+import { Produce, Consume, State } from "./app";
 import { SelectorFlags, Selector } from "./selector";
 
 export function createProducerApp(createProducerAppParams: {
-    binaryName: string,
-    name: string,
-    selector: Selector | undefined,
-    producer: Producer,
-    state: State
+  binaryName: string;
+  name: string;
+  selector?: Selector;
+  producer: Produce;
+  state: State;
 }): { run: () => Promise<void> };
 
 export function createConsumerApp(createConsumerAppParams: {
-    binaryName: string,
-    name: string,
-    selector: Selector | undefined,
-    consumer: Consumer
+  binaryName: string;
+  name: string;
+  selector?: Selector;
+  consumer: Consume;
 }): { run: () => Promise<void> };
 
 export function produceMessages(
-    producerId: string, 
-    callback: (
-        send: (topic: any, messages: any) => Promise<void>
-    ) => Promise<void>
+  producerId: string,
+  callback: (send: <T>(topic: string, messages: T) => Promise<void>) => Promise<void>,
 ): Promise<void>;
 
 export function consumeMessages(
-    consumerId: string, 
-    topic: string | RegExp, 
-    callback: (
-        message: KafkaMessage, 
-        stopConsumeMessages: () => Promise<void>
-    ) => Promise<void>
+  consumerId: string,
+  topic: string | RegExp,
+  callback: (message: KafkaMessage, stopConsumeMessages: () => Promise<void>) => Promise<void>,
 ): Promise<() => Promise<void>>;
 
-export function getProducerLatestId(
-    name: string,
-    selectorFlags: SelectorFlags
-): Promise<number>;
+export function getProducerLatestId(name: string, selectorFlags: SelectorFlags): Promise<number>;

package/log.d.ts

@@ -1,5 +1,8 @@
+export function getLine(params: any[]): string;
+
 export function print(o: any): string;
+
 export const inline: {
-    log: (...args: any[]) => void,
-    error: (...args: any[]) => void
+  log: (...args: any[]) => void;
+  error: (...args: any[]) => void;
 };

package/monitor.d.ts

@@ -2,23 +2,23 @@ import { Check } from "./app";
 import { SelectorFlags, Selector } from "./selector";
 
 export const ERROR_LEVEL: {
-    INFO: string,
-    CRITICAL: string,
-    WARNING: string
+  INFO: string;
+  CRITICAL: string;
+  WARNING: string;
 };
 
 export const LEVEL_EMOJI: {
-    Info: string,
-    Critical: string,
-    Warning: string
+  Info: string;
+  Critical: string;
+  Warning: string;
 };
 
 export function createMonitor(createMonitorParams: {
-    binaryName: string,
-    name: string,
-    getState: ((name: string, selectorFlags: SelectorFlags) => Promise<void>) | undefined,
-    mode: boolean | undefined,
-    selector: Selector,
-    check: Check,
-    maxRetry: number | undefined
+  binaryName: string;
+  name: string;
+  getState?: (name: string, selectorFlags: SelectorFlags) => Promise<void>;
+  mode?: boolean;
+  selector?: Selector;
+  check?: Check;
+  maxRetry?: number;
 }): { monitor: () => void };

package/opensearch.d.ts

@@ -4,13 +4,13 @@ export declare function newOpensearchClient(
   endpoint: string,
   key: string,
   secret: string,
-  options?: ClientOptions
+  options?: ClientOptions,
 ): Client;
 
-export declare async function sendToOpensearch(
+export declare async function sendToOpensearch<T>(
   client: Client,
   appName: string,
   index: string,
   record: string,
-  indexSuffixes?: string[]
-): Promise<{ status: string; result: Object }>;
+  indexSuffixes?: string[],
+): Promise<{ status: string; result: T }>;

package/opsgenie.d.ts

@@ -1,7 +1,7 @@
-export function postGenieMessage(
-    body: any | {
-        alias: string, 
-        message: string
-    }, 
-    verbose: boolean
-): Promise<{ result: string }>;
+export function postGenieMessage<T>(
+  body: {
+    alias?: string;
+    message: string;
+  },
+  verbose?: boolean,
+): Promise<{ result: T }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@certik/skynet",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Skynet Shared JS library",
   "type": "module",
   "main": "index.js",
@@ -8,7 +8,7 @@
   "scripts": {
     "lint": "eslint *.js test",
     "test": "doppler run -- ava --timeout=1m",
-    "format": "prettier --write '*.js' '**/*.js'",
+    "format": "prettier --write '*.js' '**/*.js' '*.d.ts' '**/*.d.ts'",
     "pub": "npm publish --access public"
   },
   "engines": {
@@ -43,4 +43,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/proxy.d.ts

@@ -1,9 +1,9 @@
 type Options = {
-    verbose: boolean;
-    timeout: number;
-    headers: {
-        [header: string]: string;
-    }
-} | RequestInit;
+  verbose: boolean;
+  timeout: number;
+  headers: {
+    [header: string]: string;
+  };
+} & RequestInit;
 
-export default function proxyFetch(url: string, options: Partial<Options> | undefined): Promise<Response>;
+export default function proxyFetch(url: string, options?: Partial<Options>): Promise<Response>;

package/s3.d.ts

@@ -1,16 +1,36 @@
-import { S3 } from "aws-sdk";
+import {
+  S3Client,
+  GetObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  DeleteObjectCommand,
+  ListObjectsV2Command,
+  NotFound,
+} from "@aws-sdk/client-s3";
 
 type WriteOptions = {
-    verbose: boolean;
-    acl: string;
-    skipIfExists: boolean;
-}
+  verbose: boolean;
+  acl: string;
+  skipIfExists: boolean;
+  contentType: string;
+};
 
-export function getS3(): S3;
-export function readFile(bucketName: string, key: string, verbose: boolean | undefined): Promise<string | null>;
+export function getS3(): S3Client;
+export function readFile(bucketName: string, key: string, verbose?: boolean): Promise<string | null>;
 export function hasFile(bucketName: string, key: string): Promise<boolean>;
-export function writeFile(bucketName: string, key: string, body: any, options: Partial<WriteOptions> | undefined): Promise<void>;
-export function deleteFile(bucketName: string, key: string, verbose: boolean | undefined): Promise<void>;
-export function listKeys(bucketname: string, prefix: string, continuationToken: string | undefined): Promise<{
-    keys: (string | undefined)[];
+export function getFileSize(bucketName: string, key: string): Promise<number>;
+export function writeFile(
+  bucketName: string,
+  key: string,
+  body: string,
+  options?: Partial<WriteOptions>,
+): Promise<void>;
+export function deleteFile(bucketName: string, key: string, verbose?: boolean): Promise<void>;
+export function listKeys(
+  bucketname: string,
+  prefix: string,
+  continuationToken?: string,
+): Promise<{
+  keys: string[];
+  continuationToken: string | null;
 } | null>;

package/selector.d.ts

@@ -1,19 +1,19 @@
 export type SelectorFlags = {
-    [flag: string]: string;
-}
+  [flag: string]: string;
+};
 
 export type Selector = {
-    [key: string]: {
-        type: string;
-        description: string | undefined;
-        desc: string | undefined;
-        alias: string | undefined,
-        isRequired: boolean | undefined,
-        default: string | boolean | undefined;
-    }
-}
+  [key: string]: {
+    type?: "string" | "number" | "boolean" | string;
+    description?: string;
+    desc?: string;
+    alias?: string;
+    isRequired?: boolean;
+    default?: any;
+  };
+};
 
-export function getJobName(name: string, selectorFlags: SelectorFlags, mode: string | undefined): string;
+export function getJobName(name: string, selectorFlags: SelectorFlags, mode?: string): string;
 export function getSelectorDesc(selector: Selector): string;
 export function getSelectorFlags(selector: Selector): SelectorFlags;
-export function toSelectorString(selectorFlags: SelectorFlags, delim: string | undefined): string;
+export function toSelectorString(selectorFlags: SelectorFlags, delim?: string): string;

package/slack.d.ts

@@ -1,10 +1,10 @@
-import { WebClient } from "@slack/web-api";
+import { ChatPostMessageArguments } from "@slack/web-api";
 
-type ChannelConfig = {
-  name: string;
-  id: string;
-};
+interface PostMessageParams {
+  conversationId: string;
+  message: string | Partial<ChatPostMessageArguments>;
+  token: string;
+  verbose?: boolean;
+}
 
-export function getClient(): WebClient;
-export function findConversation(client: WebClient, name: string): Promise<string | null>;
-export function postMessage(channel: string | ChannelConfig, message: any, verbose: boolean): Promise<void>;
+async function postMessageToConversation(params: PostMessageParams): Promise<void>;

package/snowflake.d.ts

@@ -1,4 +1,4 @@
 import { ConnectionOptions, Connection, Binds } from "snowflake-sdk";
 
 export function getConnection(options: ConnectionOptions): Promise<Connection>;
-export function executeSql(options: ConnectionOptions, sql: string, binds: Binds): Promise<any[]>;
+export function executeSql<T>(options: ConnectionOptions, sql: string, binds?: Binds): Promise<T[]>;

package/sqs.d.ts

@@ -1,3 +1,3 @@
-import { SQS } from "aws-sdk";
+import { SQSClient } from "@aws-sdk/client-sqs";
 
-export function getSQS(): SQS;
+export function getSQS(): SQSClient;

package/util.d.ts

@@ -1,4 +1,4 @@
-export function arrayGroup<T>(array:T[], groupSize: number): T[][];
+export function arrayGroup<T>(array: T[], groupSize: number): T[][];
 export function partition(startAt: number, endAt: number, numGroups: number): [number, number][];
 export function range(startAt: number, endAt: number, step: number): [number, number][];
 export function fillRange(startAt: number, endAt: number): number[];

package/web3.d.ts

@@ -2,22 +2,24 @@ import Bottleneck from "bottleneck";
 import Web3 from "web3";
 import { ABI } from "./abi";
 
-type Call = {
-    params: any | any[],
-    functionName: string | undefined,
-    target: string | undefined
-} | any[];
+type Call =
+  | {
+      params: any | any[];
+      functionName?: string;
+      target?: string;
+    }
+  | any[];
 
-export function newWeb3ByProtocol(protocol: string): Web3
+export function newWeb3ByProtocol(protocol: string): Web3;
 export function singleCall(protocol: string, abi: ABI, target: string, params: any[]): Promise<any>;
 export function multiCall(multiCallParams: {
-    protocol: string;
-    limiter: Bottleneck | undefined;
-    target: string;
-    abi: ABI;
-    calls: Call[];
+  protocol: string;
+  limiter?: Bottleneck;
+  target: string;
+  abi: ABI;
+  calls: Call[];
 }): Promise<{
-    callCount: number;
-    actualCallCount: number | undefined;
-    output: any[];
+  callCount: number;
+  actualCallCount?: number;
+  output: any[];
 }>;