gcf-common-lib 0.23.11 → 0.23.13

package/.prettierrc

@@ -0,0 +1,9 @@
+{
+  "printWidth": 120,
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true,
+  "arrowParens": "avoid",
+  "bracketSameLine": true
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gcf-common-lib",
   "description": "",
-  "version": "0.23.11",
+  "version": "0.23.13",
   "publishConfig": {
     "access": "public",
     "branches": [

package/src/index.js

@@ -33,10 +33,7 @@ class GcfCommon {
      */
     static process(event, context, handler, timeout = 535) {
         return __awaiter(this, void 0, void 0, function* () {
-            return Promise.race([
-                (0, utils_1.timeoutAfter)(timeout),
-                handler(event, context),
-            ])
+            return Promise.race([(0, utils_1.timeoutAfter)(timeout), handler(event, context)])
                 .then((res) => __awaiter(this, void 0, void 0, function* () {
                 // console.log('res:', res);
                 yield this.publish(event, context, res);
@@ -63,8 +60,7 @@ class GcfCommon {
             if (!(0, isEmpty_1.default)(topic)) {
                 return exports.pubSub.topic(topic).publishMessage({
                     json: json !== null && json !== void 0 ? json : {},
-                    attributes: Object.assign(Object.assign({}, (0, fromPairs_1.default)(Object.entries(attributes !== null && attributes !== void 0 ? attributes : {})
-                        .map(([k, v]) => [k, '' + v]))), { env: env !== null && env !== void 0 ? env : '', requestId: requestId !== null && requestId !== void 0 ? requestId : '', type: 'response', response: '1' }),
+                    attributes: Object.assign(Object.assign({}, (0, fromPairs_1.default)(Object.entries(attributes !== null && attributes !== void 0 ? attributes : {}).map(([k, v]) => [k, '' + v]))), { env: env !== null && env !== void 0 ? env : '', requestId: requestId !== null && requestId !== void 0 ? requestId : '', type: 'response', response: '1' }),
                 });
             }
         });

package/src/index.ts

@@ -1,193 +1,182 @@
-import {PubSub} from "@google-cloud/pubsub";
-import fromPairs from "lodash/fromPairs";
-import isEmpty from "lodash/isEmpty";
-import noop from "lodash/noop";
-import {timeoutAfter} from "./utils";
-import {File, Storage} from "@google-cloud/storage";
-import {SecretManagerServiceClient} from "@google-cloud/secret-manager";
+import { PubSub } from '@google-cloud/pubsub';
+import fromPairs from 'lodash/fromPairs';
+import isEmpty from 'lodash/isEmpty';
+import noop from 'lodash/noop';
+import { timeoutAfter } from './utils';
+import { File, Storage } from '@google-cloud/storage';
+import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
 import Dict = NodeJS.Dict;
 
 export type TGSEvent = {
-    bucket: string;
-    contentType: string;
-    crc32c: string;
-    etag: string;
-    generation: string;
-    id: string;
-    kind: string; // 'storage#object'
-    md5Hash: string;
-    mediaLink: string;
-    metadata: {
-        // [key: string]: string,
-        topic: string,
-        requestId: string,
-        env: string,
-        options?: any,
-    };
-    metageneration: string;
-    name: string;
-    selfLink: string;
-    size: string;
-    storageClass: string;
-    timeCreated: string;
-    timeStorageClassUpdated: string;
-    updated: string;
-}
+  bucket: string;
+  contentType: string;
+  crc32c: string;
+  etag: string;
+  generation: string;
+  id: string;
+  kind: string; // 'storage#object'
+  md5Hash: string;
+  mediaLink: string;
+  metadata: {
+    // [key: string]: string,
+    topic: string;
+    requestId: string;
+    env: string;
+    options?: any;
+  };
+  metageneration: string;
+  name: string;
+  selfLink: string;
+  size: string;
+  storageClass: string;
+  timeCreated: string;
+  timeStorageClassUpdated: string;
+  updated: string;
+};
 
 export type TPSEvent = {
-    '@type': string; // 'type.googleapis.com/google.pubsub.v1.PubsubMessage'
-    attributes?: {
-        // [k: string]: string,
-        topic: string,
-        requestId: string,
-        env: string,
-        options?: any,
-    };
-    data?: string | Dict<any>;
-}
+  '@type': string; // 'type.googleapis.com/google.pubsub.v1.PubsubMessage'
+  attributes?: {
+    // [k: string]: string,
+    topic: string;
+    requestId: string;
+    env: string;
+    options?: any;
+  };
+  data?: string | Dict<any>;
+};
 
 export type TEvent = TGSEvent | TPSEvent;
 
 export type TContext = {
-    eventId: string;
-    timestamp: string;
-    eventType: 'google.storage.object.finalize' | 'google.pubsub.topic.publish';
-    resource: {
-        service: 'storage.googleapis.com' | 'pubsub.googleapis.com';
-        type: 'storage#object' | 'type.googleapis.com/google.pubsub.v1.PubsubMessage';
-        name: string;
-    }
-}
+  eventId: string;
+  timestamp: string;
+  eventType: 'google.storage.object.finalize' | 'google.pubsub.topic.publish';
+  resource: {
+    service: 'storage.googleapis.com' | 'pubsub.googleapis.com';
+    type: 'storage#object' | 'type.googleapis.com/google.pubsub.v1.PubsubMessage';
+    name: string;
+  };
+};
 
 export type TResponse = {
-    [prop: string]: any,
-    error?: {
-        name: string,
-        message: string,
-        stack?: string,
-    }
-}
+  [prop: string]: any;
+  error?: {
+    name: string;
+    message: string;
+    stack?: string;
+  };
+};
 
 export const pubSub = new PubSub();
 export const storage = new Storage();
 export const secretClient = new SecretManagerServiceClient();
 
 export class GcfCommon {
-
-    /**
-     *
-     * @param {!TEvent} event Event payload.
-     * @param {!TContext} context Metadata for the event.
-     * @param handler
-     * @param timeout Seconds
-     */
-    static async process<T extends TResponse>(
-        event: TEvent,
-        context: TContext,
-        handler: (event: TEvent, context: TContext) => Promise<T>,
-        timeout = 535,
-    ) {
-        return Promise.race([
-            timeoutAfter(timeout),
-            handler(event, context),
-        ])
-            .then(async (res: T | undefined) => {
-                // console.log('res:', res);
-                await this.publish(event, context, res);
-            })
-            .catch(async (err: Error) => {
-                const fname = process?.env?.K_SERVICE ?? 'UNKNOWN';
-                const response: TResponse = {
-                    error: {
-                        name: err.name,
-                        message: `GCF [${fname}]: ${err.message}`,
-                        stack: err.stack,
-                    },
-                };
-                await this.publish(event, context, response, {error: '1'}).catch(noop);
-                throw err;
-            });
-    }
-
-    static async publish(event: TEvent, context: TContext, json?: TResponse, attributes?: Dict<any>) {
-        const {topic, requestId, env} = await this.getTopic(event, context);
-        console.log('publish:', topic, env, json, attributes);
-
-        if (!isEmpty(topic)) {
-            return pubSub.topic(topic as string).publishMessage({
-                json: json ?? {},
-                attributes: {
-                    ...fromPairs(
-                        Object.entries(attributes ?? {})
-                            .map(([k, v]) => [k, '' + v])
-                    ),
-                    env: env ?? '',
-                    requestId: requestId ?? '',
-                    type: 'response',
-                    response: '1',
-                },
-            });
-        }
+  /**
+   *
+   * @param {!TEvent} event Event payload.
+   * @param {!TContext} context Metadata for the event.
+   * @param handler
+   * @param timeout Seconds
+   */
+  static async process<T extends TResponse>(
+    event: TEvent,
+    context: TContext,
+    handler: (event: TEvent, context: TContext) => Promise<T>,
+    timeout = 535,
+  ) {
+    return Promise.race([timeoutAfter(timeout), handler(event, context)])
+      .then(async (res: T | undefined) => {
+        // console.log('res:', res);
+        await this.publish(event, context, res);
+      })
+      .catch(async (err: Error) => {
+        const fname = process?.env?.K_SERVICE ?? 'UNKNOWN';
+        const response: TResponse = {
+          error: {
+            name: err.name,
+            message: `GCF [${fname}]: ${err.message}`,
+            stack: err.stack,
+          },
+        };
+        await this.publish(event, context, response, { error: '1' }).catch(noop);
+        throw err;
+      });
+  }
+
+  static async publish(event: TEvent, context: TContext, json?: TResponse, attributes?: Dict<any>) {
+    const { topic, requestId, env } = await this.getTopic(event, context);
+    console.log('publish:', topic, env, json, attributes);
+
+    if (!isEmpty(topic)) {
+      return pubSub.topic(topic as string).publishMessage({
+        json: json ?? {},
+        attributes: {
+          ...fromPairs(Object.entries(attributes ?? {}).map(([k, v]) => [k, '' + v])),
+          env: env ?? '',
+          requestId: requestId ?? '',
+          type: 'response',
+          response: '1',
+        },
+      });
     }
-
-    static async getTopic(event: TEvent, context: TContext) {
-
-        /** t_{GUID}__{YYYY-MM-DD} */
-        let topic: string | undefined;
-        let requestId: string | undefined;
-        let env: string | undefined;
-
-        switch (context?.eventType) {
-            case 'google.storage.object.finalize': {
-                const gsEvent = event as TGSEvent;
-                ({topic, requestId, env} = gsEvent?.metadata ?? {});
-                if (!topic && context?.resource?.type === 'storage#object') {
-                    const [meta] = await storage.bucket(gsEvent.bucket).file(gsEvent.name).getMetadata();
-                    ({topic, requestId, env} = meta?.metadata ?? {});
-                }
-                break;
-            }
-            case 'google.pubsub.topic.publish' : {
-                const psEvent = event as TPSEvent;
-                ({topic, requestId, env} = psEvent?.attributes ?? {} as any);
-                break;
-            }
+  }
+
+  static async getTopic(event: TEvent, context: TContext) {
+    /** t_{GUID}__{YYYY-MM-DD} */
+    let topic: string | undefined;
+    let requestId: string | undefined;
+    let env: string | undefined;
+
+    switch (context?.eventType) {
+      case 'google.storage.object.finalize': {
+        const gsEvent = event as TGSEvent;
+        ({ topic, requestId, env } = gsEvent?.metadata ?? {});
+        if (!topic && context?.resource?.type === 'storage#object') {
+          const [meta] = await storage.bucket(gsEvent.bucket).file(gsEvent.name).getMetadata();
+          ({ topic, requestId, env } = meta?.metadata ?? {});
         }
-
-        return {topic, requestId, env};
+        break;
+      }
+      case 'google.pubsub.topic.publish': {
+        const psEvent = event as TPSEvent;
+        ({ topic, requestId, env } = psEvent?.attributes ?? ({} as any));
+        break;
+      }
     }
 
-    static async getOptions(event: TEvent, context: TContext): Promise<Dict<any>> {
-        switch (context?.eventType) {
-            case 'google.storage.object.finalize': {
-                const gsEvent = event as TGSEvent;
-                if (gsEvent?.metadata?.options) {
-                    return JSON.parse(gsEvent?.metadata?.options ?? '{}');
-                } else {
-                    const file: File = storage.bucket(gsEvent.bucket).file(gsEvent.name);
-                    const [meta] = await file.getMetadata();
-                    return JSON.parse(meta?.metadata?.options ?? '{}');
-                }
-            }
-            case 'google.pubsub.topic.publish' : {
-                const psEvent = event as TPSEvent;
-                return JSON.parse(psEvent?.attributes?.options ?? '{}');
-            }
+    return { topic, requestId, env };
+  }
+
+  static async getOptions(event: TEvent, context: TContext): Promise<Dict<any>> {
+    switch (context?.eventType) {
+      case 'google.storage.object.finalize': {
+        const gsEvent = event as TGSEvent;
+        if (gsEvent?.metadata?.options) {
+          return JSON.parse(gsEvent?.metadata?.options ?? '{}');
+        } else {
+          const file: File = storage.bucket(gsEvent.bucket).file(gsEvent.name);
+          const [meta] = await file.getMetadata();
+          return JSON.parse(meta?.metadata?.options ?? '{}');
         }
+      }
+      case 'google.pubsub.topic.publish': {
+        const psEvent = event as TPSEvent;
+        return JSON.parse(psEvent?.attributes?.options ?? '{}');
+      }
     }
-
-    static async getSecret(name: string, version?: string) {
-        const projectId = await secretClient.getProjectId();
-        const secretName = `projects/${projectId}/secrets/${name}`;
-        const secretVersion = `${secretName}/versions/${version ?? 'latest'}`;
-        const [response] = await secretClient.accessSecretVersion({name: secretVersion});
-        return response?.payload?.data?.toString();
-    }
-
-    static async getSecrets(names: string[], versions?: string[]) {
-        return Promise.all(
-            names.map(async (name, idx) =>
-                this.getSecret(name, versions?.[idx]).catch())
-        );
-    }
+  }
+
+  static async getSecret(name: string, version?: string) {
+    const projectId = await secretClient.getProjectId();
+    const secretName = `projects/${projectId}/secrets/${name}`;
+    const secretVersion = `${secretName}/versions/${version ?? 'latest'}`;
+    const [response] = await secretClient.accessSecretVersion({ name: secretVersion });
+    return response?.payload?.data?.toString();
+  }
+
+  static async getSecrets(names: string[], versions?: string[]) {
+    return Promise.all(names.map(async (name, idx) => this.getSecret(name, versions?.[idx]).catch()));
+  }
 }

package/src/mongo-helper.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongoHelper = void 0;
+const mongodb_1 = require("mongodb");
 class MongoHelper {
     static collectionExists(client, name) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -32,5 +33,18 @@ class MongoHelper {
             return coll;
         });
     }
+    withMongoClient(fn, url, mongoClientOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mongoClient = new mongodb_1.MongoClient(url, mongoClientOptions);
+            return yield mongoClient
+                .connect()
+                .then((client) => __awaiter(this, void 0, void 0, function* () {
+                return yield fn(client);
+            }))
+                .finally(() => __awaiter(this, void 0, void 0, function* () {
+                yield mongoClient.close();
+            }));
+        });
+    }
 }
 exports.MongoHelper = MongoHelper;

package/src/mongo-helper.ts

@@ -1,30 +1,42 @@
-import {Collection, CreateCollectionOptions, MongoClient} from "mongodb";
-import {Document} from "bson";
+import { Collection, CreateCollectionOptions, MongoClient, MongoClientOptions } from 'mongodb';
+import { Document } from 'bson';
 
 export class MongoHelper {
-    static async collectionExists(client: MongoClient, name: string) {
-        const db = client.db();
-        const collections = await db.listCollections({name}, {nameOnly: true}).toArray();
-        return collections.length > 0;
-    }
-
-    static async collectionSafeGet<TSchema extends Document = Document>(
-        client: MongoClient,
-        name: string,
-        options?: CreateCollectionOptions,
-        afterCreate?: (col: Collection<TSchema>) => Promise<void>,
-    ) {
-        const db = client.db();
-        let coll: Collection<TSchema>;
+  static async collectionExists(client: MongoClient, name: string) {
+    const db = client.db();
+    const collections = await db.listCollections({ name }, { nameOnly: true }).toArray();
+    return collections.length > 0;
+  }
 
-        if (await this.collectionExists(client, name)) {
-            coll = db.collection<TSchema>(name);
-        } else {
-            coll = await db.createCollection<TSchema>(name, options);
-            afterCreate && (await afterCreate(coll));
-        }
+  static async collectionSafeGet<TSchema extends Document = Document>(
+    client: MongoClient,
+    name: string,
+    options?: CreateCollectionOptions,
+    afterCreate?: (col: Collection<TSchema>) => Promise<void>,
+  ) {
+    const db = client.db();
+    let coll: Collection<TSchema>;
 
-        return coll;
+    if (await this.collectionExists(client, name)) {
+      coll = db.collection<TSchema>(name);
+    } else {
+      coll = await db.createCollection<TSchema>(name, options);
+      afterCreate && (await afterCreate(coll));
     }
 
-}
+    return coll;
+  }
+
+  async withMongoClient(fn: (db: MongoClient) => Promise<void>, url: string, mongoClientOptions?: MongoClientOptions) {
+    const mongoClient = new MongoClient(url, mongoClientOptions);
+
+    return await mongoClient
+      .connect()
+      .then(async client => {
+        return await fn(client);
+      })
+      .finally(async () => {
+        await mongoClient.close();
+      });
+  }
+}

package/src/mongo-lock.js

@@ -24,10 +24,9 @@ class MongoLock {
     getCollection() {
         return __awaiter(this, void 0, void 0, function* () {
             const locksColl = yield mongo_helper_1.MongoHelper.collectionSafeGet(this.client, 'locks');
-            yield locksColl.indexExists('expiresAt')
-                .then((exists) => __awaiter(this, void 0, void 0, function* () {
+            yield locksColl.indexExists('expiresAt').then((exists) => __awaiter(this, void 0, void 0, function* () {
                 if (!exists)
-                    yield locksColl.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 });
+                    yield locksColl.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
             }));
             return locksColl;
         });
@@ -72,10 +71,22 @@ class MongoLock {
             const delay = 200;
             const count = Math.round((1000 / delay) * ttlSeconds);
             return (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(() => (0, rxjs_1.from)(this.acquireLock(name, ttlSeconds))).pipe((0, rxjs_1.map)(locked => {
-                console.log(locked);
+                // console.log(locked);
                 if (!locked)
                     throw locked;
-            }), wait ? (0, rxjs_1.retry)({ count, delay }) : rxjs_1.identity, (0, rxjs_1.switchMap)(() => fn().finally(() => this.releaseLock(name).catch(noop_1.default)))));
+            }), wait ? (0, rxjs_1.retry)({ count, delay }) : rxjs_1.identity, (0, rxjs_1.switchMap)(() => __awaiter(this, void 0, void 0, function* () { return fn().finally(() => this.releaseLock(name).catch(noop_1.default)); }))));
+        });
+    }
+    checkLock(name, waitSeconds = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const delay = 200;
+            const count = Math.round((1000 / delay) * waitSeconds);
+            const collection = yield this.getCollection();
+            return (0, rxjs_1.lastValueFrom)((0, rxjs_1.defer)(() => (0, rxjs_1.from)(collection.findOne({ _id: name }))).pipe((0, rxjs_1.map)(lock => {
+                // console.log(lock);
+                if (lock)
+                    throw lock;
+            }), waitSeconds > 0 ? (0, rxjs_1.retry)({ count, delay }) : rxjs_1.identity));
         });
     }
 }

package/src/mongo-lock.ts

@@ -1,72 +1,85 @@
-import {MongoClient, MongoError} from "mongodb";
-import moment from "moment";
-import noop from "lodash/noop";
-import {defer, from, identity, lastValueFrom, map, retry, switchMap} from "rxjs";
-import {MongoHelper} from "./mongo-helper";
+import { MongoClient, MongoError } from 'mongodb';
+import moment from 'moment';
+import noop from 'lodash/noop';
+import { defer, from, identity, lastValueFrom, map, retry, switchMap } from 'rxjs';
+import { MongoHelper } from './mongo-helper';
 
 export class MongoLock {
+  constructor(private client: MongoClient) {}
 
-    constructor(private client: MongoClient) {
-    }
-
-    async getCollection() {
-        const locksColl = await MongoHelper.collectionSafeGet(this.client, 'locks' );
-        await locksColl.indexExists('expiresAt')
-            .then(async exists => {
-                if (!exists) await locksColl.createIndex({"expiresAt": 1}, {expireAfterSeconds: 0});
-            });
-        return locksColl;
-    }
+  async getCollection() {
+    const locksColl = await MongoHelper.collectionSafeGet(this.client, 'locks');
+    await locksColl.indexExists('expiresAt').then(async exists => {
+      if (!exists) await locksColl.createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+    });
+    return locksColl;
+  }
 
-    /**
-     * Create the MongoDB collection and an expiring index on a field named "expiresAt".
-     *
-     * db.createCollection('locks');
-     * db.locks.createIndex( { "expiresAt": 1 }, { expireAfterSeconds: 0 } )
-     **/
-    async acquireLock(name: string, ttlSeconds: number) {
-        const collection = await this.getCollection();
+  /**
+   * Create the MongoDB collection and an expiring index on a field named "expiresAt".
+   *
+   * db.createCollection('locks');
+   * db.locks.createIndex( { "expiresAt": 1 }, { expireAfterSeconds: 0 } )
+   **/
+  async acquireLock(name: string, ttlSeconds: number) {
+    const collection = await this.getCollection();
 
-        // Entry gets removed automatically due to an expiry index in Mongo
-        const expiresAt = moment().add(ttlSeconds, 'seconds').toDate();
+    // Entry gets removed automatically due to an expiry index in Mongo
+    const expiresAt = moment().add(ttlSeconds, 'seconds').toDate();
 
-        try {
-            await collection.insertOne({
-                _id: name as any,
-                expiresAt,
-            });
+    try {
+      await collection.insertOne({
+        _id: name as any,
+        expiresAt,
+      });
 
-            return true;
-        } catch (ex) {
-            // 11000 means duplicate key error, which is expected on an active lock
-            if ((ex as MongoError)?.code !== 11000) {
-                // Unexpected error, what happened here :o
-                throw ex
-            }
+      return true;
+    } catch (ex) {
+      // 11000 means duplicate key error, which is expected on an active lock
+      if ((ex as MongoError)?.code !== 11000) {
+        // Unexpected error, what happened here :o
+        throw ex;
+      }
 
-            // As we got a duplicate key exception, no lock could be acquired
-            return false;
-        }
+      // As we got a duplicate key exception, no lock could be acquired
+      return false;
     }
+  }
 
-    async releaseLock(name: string) {
-        const collection = await this.getCollection();
-        return collection.deleteOne({_id: name as any});
-    }
+  async releaseLock(name: string) {
+    const collection = await this.getCollection();
+    return collection.deleteOne({ _id: name as any });
+  }
 
-    async acquireAndExecute(name: string, ttlSeconds: number, wait: boolean, fn: () => Promise<any>) {
-        const delay = 200;
-        const count = Math.round((1000 / delay) * ttlSeconds);
+  async acquireAndExecute<T = any>(name: string, ttlSeconds: number, wait: boolean, fn: () => Promise<T>) {
+    const delay = 200;
+    const count = Math.round((1000 / delay) * ttlSeconds);
 
-        return lastValueFrom(
-            defer(() => from(this.acquireLock(name, ttlSeconds))).pipe(
-                map(locked => {
-                    console.log(locked);
-                    if (!locked) throw locked;
-                }),
-                wait ? retry({count, delay}) : identity,
-                switchMap(() => fn().finally(() => this.releaseLock(name).catch(noop))),
-            ),
-        );
-    }
-}
+    return lastValueFrom(
+      defer(() => from(this.acquireLock(name, ttlSeconds))).pipe(
+        map(locked => {
+          // console.log(locked);
+          if (!locked) throw locked;
+        }),
+        wait ? retry({ count, delay }) : identity,
+        switchMap(async () => fn().finally(() => this.releaseLock(name).catch(noop))),
+      ),
+    );
+  }
+
+  async checkLock(name: string, waitSeconds: number = 0) {
+    const delay = 200;
+    const count = Math.round((1000 / delay) * waitSeconds);
+    const collection = await this.getCollection();
+
+    return lastValueFrom(
+      defer(() => from(collection.findOne({ _id: name as any }))).pipe(
+        map(lock => {
+          // console.log(lock);
+          if (lock) throw lock;
+        }),
+        waitSeconds > 0 ? retry({ count, delay }) : identity,
+      ),
+    );
+  }
+}

package/src/utils.js

@@ -46,13 +46,17 @@ function colNumToA1(columnNumber) {
             charIdxArr.push(chars.length - 1);
             columnNumber = Math.floor(columnNumber / chars.length) - 1;
         }
-        else { // If remainder is non-zero
+        else {
+            // If remainder is non-zero
             charIdxArr.push(rem - 1);
             columnNumber = Math.floor(columnNumber / chars.length);
         }
     }
     // Reverse the string and print result
-    return charIdxArr.reverse().map((n) => chars[n]).join('');
+    return charIdxArr
+        .reverse()
+        .map(n => chars[n])
+        .join('');
 }
 exports.colNumToA1 = colNumToA1;
 function A1ToColNum(value) {

package/src/utils.ts

@@ -3,55 +3,59 @@
  * @param seconds Google function timeout limit (max: 9 min)
  */
 export async function timeoutAfter(seconds: number = 540) {
-    return new Promise<undefined>((resolve, reject) => {
-        setTimeout(() => {
-            reject(new Error(`${seconds} seconds timeout exceeded`));
-        }, seconds * 1000);
-    });
+  return new Promise<undefined>((resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error(`${seconds} seconds timeout exceeded`));
+    }, seconds * 1000);
+  });
 }
 
 //
 
 export function indexToA1(idx: number) {
-    return colNumToA1(idx + 1);
+  return colNumToA1(idx + 1);
 }
 
 export function A1ToIndex(value: string) {
-    return A1ToColNum(value) - 1;
+  return A1ToColNum(value) - 1;
 }
 
 export function colNumToA1(columnNumber: number) {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-
-    // To store result (Excel column name)
-    const charIdxArr: number[] = [];
-
-    while (columnNumber > 0) {
-        // Find remainder
-        const rem = columnNumber % chars.length;
-
-        // If remainder is 0, then a
-        // 'Z' must be there in output
-        if (rem === 0) {
-            charIdxArr.push(chars.length - 1);
-            columnNumber = Math.floor(columnNumber / chars.length) - 1;
-        } else { // If remainder is non-zero
-            charIdxArr.push(rem - 1);
-            columnNumber = Math.floor(columnNumber / chars.length);
-        }
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+  // To store result (Excel column name)
+  const charIdxArr: number[] = [];
+
+  while (columnNumber > 0) {
+    // Find remainder
+    const rem = columnNumber % chars.length;
+
+    // If remainder is 0, then a
+    // 'Z' must be there in output
+    if (rem === 0) {
+      charIdxArr.push(chars.length - 1);
+      columnNumber = Math.floor(columnNumber / chars.length) - 1;
+    } else {
+      // If remainder is non-zero
+      charIdxArr.push(rem - 1);
+      columnNumber = Math.floor(columnNumber / chars.length);
     }
+  }
 
-    // Reverse the string and print result
-    return charIdxArr.reverse().map((n) => chars[n]).join('');
+  // Reverse the string and print result
+  return charIdxArr
+    .reverse()
+    .map(n => chars[n])
+    .join('');
 }
 
 export function A1ToColNum(value: string) {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    let result = 0;
-    // tslint:disable-next-line:prefer-for-of
-    for (let i = 0; i < value.length; i++) {
-        result *= chars.length;
-        result += chars.indexOf(value[i]) + 1;
-    }
-    return result;
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let result = 0;
+  // tslint:disable-next-line:prefer-for-of
+  for (let i = 0; i < value.length; i++) {
+    result *= chars.length;
+    result += chars.indexOf(value[i]) + 1;
+  }
+  return result;
 }