@bitblit/ratchet-aws-node-only 4.0.115-alpha → 4.0.119-alpha

package/lib/mail/inbound/inbound-email-ratchet.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import { S3CacheRatchet } from '@bitblit/ratchet-aws/lib/s3/s3-cache-ratchet.js';
+/// <reference types="node" />
+import { S3CacheRatchet } from '@bitblit/ratchet-aws';
 import { ParsedEmailProcessor } from './parsed-email-processor.js';
 export declare class InboundEmailRatchet {
     private cache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitblit/ratchet-aws-node-only",
-  "version": "4.0.115-alpha",
+  "version": "4.0.119-alpha",
   "description": "Common tools for use with AWS (Node only)",
   "note-on-side-effects": "Technically the entries in 'bin' below might be side effects, but they are called explicitly",
   "sideEffects": false,
@@ -8,11 +8,16 @@
     "ratchet-aws-cli": "./bin/cli.js"
   },
   "type": "module",
-  "module": "index.js",
   "files": [
     "lib/*",
     "bin/*"
   ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.mjs"
+    }
+  },
   "contributors": [
     "Christopher Weiss <bitblit@gmail.com>",
     "William Weiss <npm@codification.org>",
@@ -39,9 +44,9 @@
     "docs": "typedoc",
     "lint": "eslint src/**/*.ts",
     "lint-fix": "eslint --fix src/**/*.ts",
-    "__generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts",
-    "__build": "yarn run generate-barrels && tsc",
-    "build": "tsc"
+    "generate-barrels": "barrelsby -q --delete -d src -e .*\\.spec\\.ts && sed -i 's/\\x27;/.js\\x27;/' src/index.ts",
+    "build": "yarn clean && yarn generate-barrels && rollup -c rollup.config.js",
+    "force-build": "tsc --build --force"
   },
   "repository": {
     "type": "git",
@@ -60,35 +65,16 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/client-athena": "3.328.0",
-    "@aws-sdk/client-ec2": "3.328.0",
-    "@aws-sdk/client-ec2-instance-connect": "3.328.0",
-    "@aws-sdk/client-s3": "3.328.0",
-    "@aws-sdk/lib-storage": "3.328.0",
-    "@aws-sdk/smithy-client": "3.325.0",
-    "@aws-sdk/types": "3.310.0",
-    "@bitblit/ratchet-aws": "4.0.115-alpha",
-    "@bitblit/ratchet-common": "4.0.115-alpha",
+    "@aws-sdk/client-athena": "3.332.0",
+    "@bitblit/ratchet-aws": "4.0.119-alpha",
+    "@bitblit/ratchet-common": "4.0.119-alpha",
     "mailparser": "3.6.4",
     "mime-types": "2.1.35",
     "tmp": "0.2.1",
-    "unzipper": "0.10.11",
+    "unzipper": "0.10.14",
     "walk": "2.3.15"
   },
   "peerDependencies": {
-    "@aws-sdk/client-athena": "^3.328.0",
-    "@aws-sdk/client-ec2": "^3.328.0",
-    "@aws-sdk/client-ec2-instance-connect": "^3.328.0",
-    "@aws-sdk/client-s3": "^3.328.0",
-    "@aws-sdk/lib-storage": "^3.328.0",
-    "@aws-sdk/smithy-client": "^3.328.0",
-    "@aws-sdk/types": "^3.310.0",
-    "@bitblit/ratchet-aws": "4.0.115-alpha",
-    "@bitblit/ratchet-common": "4.0.115-alpha",
-    "mailparser": "^3.6.4",
-    "mime-types": "^2.1.35",
-    "tmp": "^0.2.1",
-    "walk": "^2.3.15"
   },
   "devDependencies": {}
 }

package/lib/athena/alb-athena-log-ratchet.js

@@ -1,156 +0,0 @@
-import { readFileSync } from 'fs';
-import path from 'path';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { EsmRatchet } from '@bitblit/ratchet-common/lib/lang/esm-ratchet.js';
-import { S3Ratchet } from '@bitblit/ratchet-aws/lib/s3/s3-ratchet.js';
-import { CsvRatchet } from '@bitblit/ratchet-node-only/lib/csv/csv-ratchet.js';
-export class AlbAthenaLogRatchet {
-    athena;
-    athenaTableName;
-    constructor(athena, athenaTableName) {
-        this.athena = athena;
-        this.athenaTableName = athenaTableName;
-        RequireRatchet.notNullOrUndefined(athena, 'athena');
-        RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(athenaTableName), 'athenaTableName');
-    }
-    async updatePartitions(rootPath, s3, startTimeEpochMS = new Date().getTime() - 1000 * 60 * 60 * 24, endTimeEpochMS = new Date().getTime()) {
-        RequireRatchet.true(S3Ratchet.checkS3UrlForValidity(rootPath), 'root path not valid');
-        RequireRatchet.notNullOrUndefined(s3, 's3');
-        Logger.info('Updating partitions for %s from %s', this.athenaTableName, rootPath);
-        const bucketName = S3Ratchet.extractBucketFromURL(rootPath);
-        const rootKey = S3Ratchet.extractKeyFromURL(rootPath);
-        let current = startTimeEpochMS;
-        const clauses = [];
-        while (current < endTimeEpochMS) {
-            const dateUtcVal = new Date(current).toISOString().substring(0, 10);
-            Logger.info('d:%s', dateUtcVal);
-            const dateParts = dateUtcVal.split('-');
-            clauses.push("PARTITION (date_utc_partition='" +
-                dateUtcVal +
-                "') LOCATION '" +
-                rootPath +
-                '/' +
-                dateParts[0] +
-                '/' +
-                dateParts[1] +
-                '/' +
-                dateParts[2] +
-                "'");
-            current += 1000 * 60 * 60 * 24;
-        }
-        if (clauses.length > 0) {
-            const stmt = 'ALTER TABLE ' + this.athenaTableName + ' ADD IF NOT EXISTS \n' + clauses.join('\n');
-            await this.athena.runQueryToObjects(stmt);
-        }
-        else {
-            Logger.warn('Not updating partitions - no time between time clauses');
-        }
-        return clauses;
-    }
-    async createTable(rootPath, replaceIfPresent = false) {
-        RequireRatchet.true(S3Ratchet.checkS3UrlForValidity(rootPath), 'root path not valid');
-        let rval = false;
-        Logger.info('Creating ALB table %s', this.athenaTableName);
-        if (replaceIfPresent) {
-            Logger.info('Replace if present specified, removed old table');
-            try {
-                await this.athena.runQueryToObjects('drop table ' + this.athenaTableName);
-            }
-            catch (err) {
-                Logger.info('Drop error : %j', err);
-            }
-        }
-        let tableCreateQry = readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../static/albAthenaTableCreate.txt')).toString();
-        tableCreateQry = tableCreateQry.split('{{TABLE NAME}}').join(this.athenaTableName);
-        tableCreateQry = tableCreateQry.split('{{ALB_LOG_ROOT}}').join(rootPath);
-        Logger.info('Creating table with %s', tableCreateQry);
-        try {
-            await this.athena.runQueryToObjects(tableCreateQry);
-            rval = true;
-        }
-        catch (err) {
-            Logger.error('Error creating table : %s', err);
-        }
-        return rval;
-    }
-    static async readLogObjectsFromCsvStream(readStream) {
-        return CsvRatchet.streamParse(readStream, (p) => p);
-    }
-    static async readLogObjectsFromFile(fileName) {
-        return CsvRatchet.fileParse(fileName, (p) => p);
-    }
-    async fetchAlbLogRecords(qry) {
-        const tempFile = await this.fetchAlbLogRecordsToFile(qry);
-        return AlbAthenaLogRatchet.readLogObjectsFromFile(tempFile);
-    }
-    async fetchAlbLogRecordsToFile(qry, outputFileName = null) {
-        Logger.info('Querying %s : %j', this.athenaTableName, qry);
-        let qrySt = 'select * from ' + this.athenaTableName + ' where 1=1 ';
-        if (qry.startTimeEpochMS) {
-            if (qry.startTimeEpochMS) {
-                qrySt += " AND time >= '" + new Date(qry.startTimeEpochMS).toISOString() + "'";
-                qrySt += " AND date_utc_partition >='" + new Date(qry.startTimeEpochMS).toISOString().substring(0, 10) + "'";
-            }
-            if (qry.endTimeEpochMS) {
-                qrySt += " AND time < '" + new Date(qry.endTimeEpochMS).toISOString() + "'";
-                qrySt += " AND date_utc_partition <='" + new Date(qry.endTimeEpochMS).toISOString().substring(0, 10) + "'";
-            }
-            if (qry.requestUrlFilter) {
-                qrySt += " AND request_url LIKE '" + qry.requestUrlFilter + "'";
-            }
-            if (qry.limit) {
-                qrySt += ' LIMIT ' + qry.limit;
-            }
-        }
-        const result = await this.athena.runQueryToFile(qrySt, null, outputFileName);
-        return result;
-    }
-    static CREATE_TABLE_STATEMENT = 'CREATE EXTERNAL TABLE IF NOT EXISTS `{{TABLE NAME}}`(\n' +
-        "  `type` string COMMENT '',\n" +
-        "  `time` string COMMENT '',\n" +
-        "  `elb` string COMMENT '',\n" +
-        "  `client_ip` string COMMENT '',\n" +
-        "  `client_port` int COMMENT '',\n" +
-        "  `target_ip` string COMMENT '',\n" +
-        "  `target_port` int COMMENT '',\n" +
-        "  `request_processing_time` double COMMENT '',\n" +
-        "  `target_processing_time` double COMMENT '',\n" +
-        "  `response_processing_time` double COMMENT '',\n" +
-        "  `elb_status_code` string COMMENT '',\n" +
-        "  `target_status_code` string COMMENT '',\n" +
-        "  `received_bytes` bigint COMMENT '',\n" +
-        "  `sent_bytes` bigint COMMENT '',\n" +
-        "  `request_verb` string COMMENT '',\n" +
-        "  `request_url` string COMMENT '',\n" +
-        "  `request_proto` string COMMENT '',\n" +
-        "  `user_agent` string COMMENT '',\n" +
-        "  `ssl_cipher` string COMMENT '',\n" +
-        "  `ssl_protocol` string COMMENT '',\n" +
-        "  `target_group_arn` string COMMENT '',\n" +
-        "  `trace_id` string COMMENT '',\n" +
-        "  `domain_name` string COMMENT '',\n" +
-        "  `chosen_cert_arn` string COMMENT '',\n" +
-        "  `matched_rule_priority` string COMMENT '',\n" +
-        "  `request_creation_time` string COMMENT '',\n" +
-        "  `actions_executed` string COMMENT '',\n" +
-        "  `redirect_url` string COMMENT '',\n" +
-        "  `lambda_error_reason` string COMMENT '',\n" +
-        "  `target_port_list` string COMMENT '',\n" +
-        "  `target_status_code_list` string COMMENT '',\n" +
-        "  `new_field` string COMMENT '')\n" +
-        'PARTITIONED BY (\n' +
-        '  `date_utc_partition` string\n' +
-        ')\n' +
-        'ROW FORMAT SERDE\n' +
-        "  'org.apache.hadoop.hive.serde2.RegexSerDe'\n" +
-        'WITH SERDEPROPERTIES (\n' +
-        '  \'input.regex\'=\'([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \\"([^ ]*) ([^ ]*) (- |[^ ]*)\\" \\"([^\\"]*)\\" ([A-Z0-9-]+) ([A-Za-z0-9.-]*) ([^ ]*) \\"([^\\"]*)\\" \\"([^\\"]*)\\" \\"([^\\"]*)\\" ([-.0-9]*) ([^ ]*) \\"([^\\"]*)\\" \\"([^\\"]*)\\" \\"([^ ]*)\\" \\"([^s]+)\\" \\"([^s]+)\\"(.*)\')\n' +
-        'STORED AS INPUTFORMAT\n' +
-        "  'org.apache.hadoop.mapred.TextInputFormat'\n" +
-        'OUTPUTFORMAT\n' +
-        "  'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'\n" +
-        'LOCATION\n' +
-        "  '{{ALB_LOG_ROOT}}'\n";
-}

package/lib/athena/alb-athena-log-ratchet.spec.js

@@ -1,25 +0,0 @@
-import { AthenaRatchet } from './athena-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { LoggerLevelName } from '@bitblit/ratchet-common/lib/logger/logger-level-name.js';
-import { TimeZoneRatchet } from '@bitblit/ratchet-common/lib/lang/time-zone-ratchet.js';
-import { AlbAthenaLogRatchet } from './alb-athena-log-ratchet.js';
-import { S3Client } from '@aws-sdk/client-s3';
-import { AthenaClient } from '@aws-sdk/client-athena';
-describe('#AlbAthenaLogRatchet', function () {
-    xit('should test a query', async () => {
-        Logger.setLevel(LoggerLevelName.debug);
-        const athena = new AthenaClient({ region: 'us-east-1' });
-        const s3 = new S3Client({ region: 'us-east-1' });
-        const outputDir = 's3://alb-log-bucket/temp';
-        const athRatchet = new AthenaRatchet(athena, s3, outputDir);
-        const srv = new AlbAthenaLogRatchet(athRatchet, 'alb_logs.log_table');
-        const qry = {
-            startTimeEpochMS: TimeZoneRatchet.PACIFIC.startOfTodayEpochMS(),
-            endTimeEpochMS: TimeZoneRatchet.PACIFIC.startOfTodayEpochMS() + 1000 * 60 * 10,
-            limit: 10,
-        };
-        const result = await srv.fetchAlbLogRecords(qry);
-        expect(result).toBeTruthy();
-        Logger.info('Got objects : %j', result);
-    });
-});

package/lib/athena/athena-ratchet.js

@@ -1,157 +0,0 @@
-import { GetNamedQueryCommand, GetQueryExecutionCommand, ListNamedQueriesCommand, StartQueryExecutionCommand, } from '@aws-sdk/client-athena';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { StopWatch } from '@bitblit/ratchet-common/lib/lang/stop-watch.js';
-import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
-import { GetObjectCommand } from '@aws-sdk/client-s3';
-import tmp from 'tmp';
-import fs from 'fs';
-import { CsvRatchet } from '@bitblit/ratchet-node-only/lib/csv/csv-ratchet.js';
-import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
-export class AthenaRatchet {
-    athena;
-    s3;
-    outputLocation;
-    constructor(athena, s3, outputLocation) {
-        this.athena = athena;
-        this.s3 = s3;
-        this.outputLocation = outputLocation;
-        RequireRatchet.notNullOrUndefined(athena);
-        RequireRatchet.notNullOrUndefined(s3);
-        RequireRatchet.notNullOrUndefined(outputLocation);
-        RequireRatchet.true(outputLocation.startsWith('s3://'));
-    }
-    static athenaRowsToObject(input) {
-        const colNames = input[0].Data.map((d) => d.VarCharValue);
-        const temp = input.slice(1);
-        const rval = temp.map((t) => {
-            const newItem = {};
-            for (let i = 0; i < t.Data.length; i++) {
-                newItem[colNames[i]] = t.Data[i].VarCharValue;
-            }
-            return newItem;
-        });
-        return rval;
-    }
-    static applyParamsToQuery(query, queryParams) {
-        let rval = query;
-        if (!!rval && !!queryParams) {
-            Object.keys(queryParams).forEach((k) => {
-                const val = StringRatchet.safeString(queryParams[k]);
-                const kk = '{' + k + '}';
-                rval = rval.split(kk).join(val);
-            });
-        }
-        return rval;
-    }
-    async fetchQueryIds() {
-        const params = {
-            NextToken: null,
-        };
-        let rval = [];
-        let next = null;
-        do {
-            next = await this.athena.send(new ListNamedQueriesCommand(params));
-            rval = rval.concat(next.NamedQueryIds);
-            params.NextToken = next.NextToken;
-        } while (!!params.NextToken);
-        return rval;
-    }
-    async listQueries() {
-        const rval = [];
-        const ids = await this.fetchQueryIds();
-        Logger.debug('Finding %d items', ids.length);
-        for (let i = 0; i < ids.length; i++) {
-            const params = {
-                NamedQueryId: ids[i],
-            };
-            const val = await this.athena.send(new GetNamedQueryCommand(params));
-            rval.push(val.NamedQuery);
-        }
-        return rval;
-    }
-    async findQueryByName(name) {
-        const all = await this.listQueries();
-        const rval = all.find((a) => a.Name.toLowerCase() == name.toLowerCase());
-        return rval;
-    }
-    async runQueryToObjects(queryIn, queryParams = {}, pingTimeMS = 2000) {
-        Logger.info('Running query to objects');
-        const outputLoc = await this.runQueryToOutputLocation(queryIn, queryParams, pingTimeMS);
-        Logger.info('Query succeeded, processing file from %s', outputLoc);
-        const bucketName = outputLoc.substring(5, outputLoc.indexOf('/', 5));
-        const obKey = outputLoc.substring(outputLoc.indexOf('/', 5) + 1);
-        const req = {
-            Bucket: bucketName,
-            Key: obKey,
-        };
-        const getFileOut = await this.s3.send(new GetObjectCommand(req));
-        const rval = await CsvRatchet.stringParse(getFileOut.Body.toString(), (p) => {
-            return p;
-        }, { columns: true, skip_empty_lines: true });
-        return rval;
-    }
-    async runQueryToFile(queryIn, queryParams = {}, targetDataFileIn = null, pingTimeMS = 2000) {
-        Logger.info('Running query to file');
-        const outputLoc = await this.runQueryToOutputLocation(queryIn, queryParams, pingTimeMS);
-        Logger.info('Query succeeded, pulling file from %s', outputLoc);
-        const bucketName = outputLoc.substring(5, outputLoc.indexOf('/', 5));
-        const obKey = outputLoc.substring(outputLoc.indexOf('/', 5) + 1);
-        const req = {
-            Bucket: bucketName,
-            Key: obKey,
-        };
-        const targetDataFile = targetDataFileIn || tmp.fileSync({ postfix: '.csv', keep: false }).name;
-        const fileStream = fs.createWriteStream(targetDataFile);
-        const output = await this.s3.send(new GetObjectCommand(req));
-        const readStream = output.Body;
-        readStream.pipe(fileStream);
-        const rval = await PromiseRatchet.resolveOnEvent(readStream, ['finish', 'close'], ['error'], targetDataFile);
-        Logger.silly('Response: %s', rval);
-        return targetDataFile;
-    }
-    async runQueryToOutputLocation(queryIn, queryParams = {}, pingTimeMS = 2000) {
-        let rval = null;
-        const timer = new StopWatch();
-        const query = AthenaRatchet.applyParamsToQuery(queryIn, queryParams);
-        try {
-            Logger.info('Starting query : %s', query);
-            const token = StringRatchet.createType4Guid();
-            const params = {
-                QueryString: query,
-                ResultConfiguration: {
-                    OutputLocation: this.outputLocation,
-                    EncryptionConfiguration: {
-                        EncryptionOption: 'SSE_S3',
-                    },
-                },
-                ClientRequestToken: token,
-                QueryExecutionContext: {
-                    Database: 'default',
-                },
-            };
-            const startToken = await this.athena.send(new StartQueryExecutionCommand(params));
-            const getExecParams = {
-                QueryExecutionId: startToken.QueryExecutionId,
-            };
-            const finalStates = ['FAILED', 'CANCELLED', 'SUCCEEDED'];
-            let curState = await this.athena.send(new GetQueryExecutionCommand(getExecParams));
-            while (finalStates.indexOf(curState.QueryExecution.Status.State) === -1) {
-                await PromiseRatchet.createTimeoutPromise('wait', pingTimeMS);
-                Logger.debug('%s : %s : %s', curState.QueryExecution.Status.State, timer.dump(), query);
-                curState = await this.athena.send(new GetQueryExecutionCommand(getExecParams));
-            }
-            if (curState.QueryExecution.Status.State === 'FAILED') {
-                Logger.warn('Query failed : %s', curState.QueryExecution.Status.StateChangeReason);
-            }
-            else if (curState.QueryExecution.Status.State === 'SUCCEEDED') {
-                rval = curState.QueryExecution.ResultConfiguration.OutputLocation;
-            }
-        }
-        catch (err) {
-            Logger.warn('Failure : %s', err, err);
-        }
-        Logger.info('Query took %s : %s', timer.dump(), query);
-        return rval;
-    }
-}

package/lib/athena/athena-ratchet.spec.js

@@ -1,27 +0,0 @@
-import { AthenaRatchet } from './athena-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { AthenaClient, GetQueryExecutionCommand, StartQueryExecutionCommand, } from '@aws-sdk/client-athena';
-import { S3Client } from '@aws-sdk/client-s3';
-import { mockClient } from 'aws-sdk-client-mock';
-let mockAthena;
-let mockS3;
-describe('#AthenaRatchet', function () {
-    mockAthena = mockClient(AthenaClient);
-    mockS3 = mockClient(S3Client);
-    beforeEach(() => {
-        mockAthena.reset();
-        mockS3.reset();
-    });
-    xit('should test a query', async () => {
-        const outputDir = 's3://your-bucket/your-prefix';
-        const qry = 'select * from test limit 20000';
-        mockAthena.on(StartQueryExecutionCommand).resolves({ jobName: 'b' });
-        mockAthena.on(GetQueryExecutionCommand).resolves({
-            QueryExecution: { ResultConfiguration: { OutputLocation: 'test' }, Status: { State: 'SUCCEEDED' } },
-        });
-        const ratchet = new AthenaRatchet(mockAthena, mockS3, outputDir);
-        const result = await ratchet.runQueryToObjects(qry);
-        expect(result).toBeTruthy();
-        Logger.info('Got objects : %j', result);
-    });
-});

package/lib/build/ratchet-aws-node-only-info.js

@@ -1,14 +0,0 @@
-export class RatchetAwsNodeOnlyInfo {
-    constructor() { }
-    static buildInformation() {
-        const val = {
-            version: 'LOCAL-SNAPSHOT',
-            hash: 'LOCAL-HASH',
-            branch: 'LOCAL-BRANCH',
-            tag: 'LOCAL-TAG',
-            timeBuiltISO: 'LOCAL-TIME-ISO',
-            notes: 'LOCAL-NOTES',
-        };
-        return val;
-    }
-}

package/lib/cli/dynamo-exporter.js

@@ -1,76 +0,0 @@
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { PromiseRatchet } from '@bitblit/ratchet-common/lib/lang/promise-ratchet.js';
-import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
-import fs from 'fs';
-import readline from 'readline';
-export class DynamoExporter {
-    constructor() { }
-    static async importJsonLFileToTable(dynamo, tableName, filename) {
-        RequireRatchet.notNullOrUndefined(dynamo, 'dynamo');
-        RequireRatchet.notNullOrUndefined(tableName, 'tableName');
-        RequireRatchet.notNullOrUndefined(filename, 'filename');
-        const fileStream = fs.createReadStream(filename);
-        const rl = readline.createInterface({
-            input: fileStream,
-            crlfDelay: Infinity,
-        });
-        let rval = 0;
-        for await (const line of rl) {
-            if (rval % 100 === 0) {
-                Logger.info('Importing line %d', rval);
-            }
-            if (StringRatchet.trimToNull(line)) {
-                const parsed = JSON.parse(line);
-                await dynamo.simplePut(tableName, parsed);
-                rval++;
-            }
-        }
-        return rval;
-    }
-    static async exportScanToJsonLFile(dynamo, scan, filename) {
-        RequireRatchet.notNullOrUndefined(dynamo, 'dynamo');
-        RequireRatchet.notNullOrUndefined(scan, 'scan');
-        RequireRatchet.notNullOrUndefined(filename, 'filename');
-        const ws = fs.createWriteStream(filename);
-        ws.on('end', () => {
-            Logger.debug('Write complete');
-        });
-        const rval = await DynamoExporter.exportScanToJsonLWriteStream(dynamo, scan, ws);
-        await PromiseRatchet.resolveOnEvent(ws, ['finish', 'close'], ['error']);
-        ws.close();
-        return rval;
-    }
-    static async exportQueryToJsonLFile(dynamo, qry, filename) {
-        RequireRatchet.notNullOrUndefined(dynamo, 'dynamo');
-        RequireRatchet.notNullOrUndefined(qry, 'qry');
-        RequireRatchet.notNullOrUndefined(filename, 'filename');
-        const ws = fs.createWriteStream(filename);
-        ws.on('end', () => {
-            Logger.debug('Write complete');
-        });
-        const rval = await DynamoExporter.exportQueryToJsonLWriteStream(dynamo, qry, ws);
-        await PromiseRatchet.resolveOnEvent(ws, ['finish', 'close'], ['error']);
-        ws.close();
-        return rval;
-    }
-    static async exportScanToJsonLWriteStream(dynamo, scan, target) {
-        RequireRatchet.notNullOrUndefined(dynamo, 'dynamo');
-        RequireRatchet.notNullOrUndefined(scan, 'scan');
-        RequireRatchet.notNullOrUndefined(target, 'target');
-        const rval = await dynamo.fullyExecuteProcessOverScan(scan, async (row) => DynamoExporter.writeItemToJsonLStream(row, target, false));
-        return rval;
-    }
-    static async exportQueryToJsonLWriteStream(dynamo, qry, target) {
-        RequireRatchet.notNullOrUndefined(dynamo, 'dynamo');
-        RequireRatchet.notNullOrUndefined(qry, 'qry');
-        RequireRatchet.notNullOrUndefined(target, 'target');
-        const rval = await dynamo.fullyExecuteProcessOverQuery(qry, async (row) => DynamoExporter.writeItemToJsonLStream(row, target, false));
-        return rval;
-    }
-    static writeItemToJsonLStream(item, target, includeNulls = false) {
-        if (!!item || includeNulls) {
-            target.write(JSON.stringify(item) + '\n');
-        }
-    }
-}

package/lib/cli/ratchet-cli-handler.js

@@ -1,15 +0,0 @@
-import { AbstractRatchetCliHandler } from '@bitblit/ratchet-node-only/lib/cli/abstract-ratchet-cli-handler.js';
-import { SiteUploader } from './site-uploader/site-uploader.js';
-import { StartInstanceAndSsh } from './start-instance-and-ssh.js';
-import { RatchetAwsNodeOnlyInfo } from '../build/ratchet-aws-node-only-info.js';
-export class RatchetCliHandler extends AbstractRatchetCliHandler {
-    fetchHandlerMap() {
-        return {
-            'site-uploader': SiteUploader.runFromCliArgs,
-            'start-instance-and-ssh': StartInstanceAndSsh.runFromCliArgs,
-        };
-    }
-    fetchVersionInfo() {
-        return RatchetAwsNodeOnlyInfo.buildInformation();
-    }
-}