@nmakarov/cli-toolkit 0.11.2 → 0.11.4

package/dist/index.js

@@ -2506,14 +2506,26 @@ var FileDatabase = class {
   figureOutDataAndFileToWrite(data) {
     let dataToWrite;
     let dataLeftOver;
-    if (!this.metadata.dataType) {
-      this.metadata.dataType = detectDataType(data);
+    const incomingDataType = detectDataType(data);
+    if (this.metadata.dataType !== incomingDataType) {
+      this.metadata.dataType = incomingDataType;
     }
     if (this.metadata.files.length === 0) {
       this.makeNewFile();
     }
     const lastFile = this.metadata.files[this.metadata.files.length - 1];
     const lastFileRecordsCount = lastFile.recordsCount;
+    if (!Array.isArray(data)) {
+      const lastFileExtension = path3.extname(lastFile.fileName);
+      const expectedExtension = `.${getFileExtension(incomingDataType)}`;
+      if (lastFileExtension !== expectedExtension) {
+        if (lastFileRecordsCount > 0) {
+          this.makeNewFile();
+        } else {
+          lastFile.fileName = `${this.currentFileNumber.toString().padStart(6, "0")}.${getFileExtension(incomingDataType)}`;
+        }
+      }
+    }
     if (Array.isArray(data)) {
       if (lastFileRecordsCount < this.pageSize) {
         dataToWrite = [...this.lastFileData || [], ...data.slice(0, this.pageSize - lastFileRecordsCount)];
@@ -2696,10 +2708,13 @@ var FileDatabase = class {
       throw new FileDatabaseError("Cannot use forceNewVersion in non-versioned mode");
     }
     await this.prepare({ write: true });
+    const incomingDataType = detectDataType(data);
+    this.metadata.dataType = incomingDataType;
     if (options.forceNewVersion) {
       await this.makeNewVersion();
       this.metadata = this.getDefaultMetadata();
       this.metadata.version = this.currentVersion;
+      this.metadata.dataType = incomingDataType;
       this.makeNewFile();
     }
     let { dataToWrite, dataLeftOver, fileName } = this.figureOutDataAndFileToWrite(data);
@@ -2839,6 +2854,10 @@ var Db = class {
   logger;
   queriesLog = [];
   isConnected = false;
+  /**
+   * Constructor - accepts config object
+   * Use dbInit() function to initialize with Context
+   */
   constructor(config2) {
     if (!config2.connectionString) {
       throw new ParamError("Db: connectionString is required");
@@ -3125,6 +3144,91 @@ var Db = class {
     return this.isConnected && this.knexInstance !== null;
   }
 };
+function capitalizeFirstLetter(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+async function dbConnect(context, connectionString, name, dbProfile) {
+  const defs = {
+    testDbConnection: "boolean default true",
+    name: "string",
+    poolMin: "number default 2",
+    poolMax: "number default 10",
+    acquireConnectionTimeout: "number default 10000",
+    sslRejectUnauthorized: "boolean default false"
+  };
+  const paramsConfig = context.params.getAll(defs);
+  const config2 = {
+    connectionString,
+    name: paramsConfig.name || name || "default",
+    testConnection: paramsConfig.testDbConnection,
+    profile: dbProfile ?? false,
+    pool: {
+      min: paramsConfig.poolMin,
+      max: paramsConfig.poolMax
+    },
+    acquireConnectionTimeout: paramsConfig.acquireConnectionTimeout,
+    ssl: {
+      rejectUnauthorized: paramsConfig.sslRejectUnauthorized
+    },
+    logger: context.logger
+  };
+  try {
+    const db = new Db(config2);
+    context.registerCleanup(async () => {
+      await db.disconnect();
+      context.logger.debug(`[Db] instance "${name || connectionString}" destroyed`);
+    });
+    await db.connect();
+    context.logger.debug(`[Db] instance "${name || connectionString}" initialized`);
+    return db;
+  } catch (error) {
+    if (error instanceof ParamError) {
+      throw error;
+    }
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    throw new ParamError(`[Db] connect error: ${errorMsg}`);
+  }
+}
+async function dbFindAndConnect(context, dbNameOrConnectionString) {
+  let dbName;
+  let dbConnectionString;
+  let dbProfile;
+  if (dbNameOrConnectionString) {
+    if (dbNameOrConnectionString.match(/^(postgresql|mysql):\/\/[^\s]+:[^\s]+@[^\s]+:\d+\/[^\s]+$/)) {
+      dbName = void 0;
+      dbConnectionString = dbNameOrConnectionString;
+    } else {
+      dbName = dbNameOrConnectionString;
+    }
+  } else {
+    const defs = {
+      dbName: "string",
+      dbConnectionString: "string",
+      dbProfile: "boolean default false"
+    };
+    const paramsConfig = context.params.getAll(defs);
+    dbName = paramsConfig.dbName;
+    dbConnectionString = paramsConfig.dbConnectionString;
+    dbProfile = paramsConfig.dbProfile;
+  }
+  if (!dbName && !dbConnectionString) {
+    throw new ParamError("Db: either dbName or dbConnectionString must be specified");
+  }
+  if (dbName) {
+    const paramName = `dbConnectionString${capitalizeFirstLetter(dbName)}`;
+    dbConnectionString = await context.params.get(paramName, "string");
+    if (!dbConnectionString) {
+      throw new ParamError(
+        `Db: cannot find dbConnectionString for dbName="${dbName}" (looked for param "${paramName}")`
+      );
+    }
+  }
+  const db = await dbConnect(context, dbConnectionString, dbName, dbProfile);
+  return db;
+}
+async function dbInit(context, dbNameOrConnectionString) {
+  return await dbFindAndConnect(context, dbNameOrConnectionString);
+}
 
 // src/logger/index.ts
 import chalk from "chalk";
@@ -3519,6 +3623,9 @@ export {
   buildBreadcrumb,
   buildDetailBreadcrumb,
   buildFooter,
+  dbConnect,
+  dbFindAndConnect,
+  dbInit,
   defaultFileSynopsisFunction,
   defaultVersionSynopsisFunction,
   fileDatabaseInit,