@adinsure-ops/ops-cli 4.8.2 → 5.0.0-rc3

package/CHANGELOGS.md

@@ -1,5 +1,17 @@
 # Changelogs
 
+## 5.0.0-rc1
+
+- bugfixes
+- security patching: the project was migrated to a new oclif framework from the old one
+- performace tuning
+- removal of the prepare-content command
+
+## 4.8.3: 2023-08-22
+
+- bugfixes; sql command was fixed so that even when Extend was not used it required its parameters
+- security patches in library dependencies
+
 ## 4.8.2: 2023-07-28
 
 - sql command can now generate a template for mssql and oracle, for extending an sql table with a column

package/README.md

@@ -47,7 +47,6 @@ You can run and debug commands directly from terminal by running `ops [command]`
 - [`ops npm:publish`](##ops-npm:publish)
 - [`ops npm:dependency-update`](##ops-npm:dependency-update)
 - [`ops nuget:dependency-update`](##ops-nuget:dependency-update)
-- [`ops prepare-content`](##ops-prepare-content)
 - [`ops sql <type> <module> [flags]`](##ops-sql-<type>-<module>-[flags])
 - [`ops translate`](##ops-translate)
 - [`ops version <type> [flags]`](##ops-version-<type>[flags])
@@ -487,216 +486,6 @@ EXAMPLE
   $ ops nuget:dependency-update 3.4.3 --filter Adacta.AdInsure --exclude Scheduler
 ```
 
-## `ops prepare-content -d <destination> -s [source]`
-
-creates a directory/file structure from `/source` to `/destination</source>` as defined in the `.opsprepare` file. Actual
-destination path for each file will be specified destination path with appended relative path from working directory where command is executed to specified source directory or current directory (if source is not specified). Be careful about using
-`..` notation in target and source paths as it may lead to unpredictable results due to relative path resolving.
-
-> Introduced in version 3.1.0.
-
-```txt
-USAGE
-  $ ops prepare-content -d <destination> -s [source]
-
-
-OPTIONS
-  -d, --destination=destination       path to target directory
-  -s, --source=source                 optional path to source directory containing .opsprepare file, (default: current directory)
-
-EXAMPLES
-$ ops prepare-content -d ./target_directory/
-  copies everything defined in .opsprepare
-  from current directory 
-  to ./target_directory
-
-$ ops prepare-content -d ./target_directory/ -s ./source_directory
-  copies everything defined in ./source_directory/.opsprepare 
-  from ./source_directory/
-  to ./target_directory/source_directory
-
-$ ops prepare-content -d C:\git\target_directory
-  copies everything defined in .opsprepare 
-  from current directory 
-  to C:\git\target_directory
-
-$ ops prepare-content -d C:\git\target_directory -s C:\git\subfolder\subfolder
-  when executed in c:\git it copies everything defined in C:\git\subfolder\subfolder\.opsprepare 
-  from C:\git\subfolder\subfolder
-  to C:\git\target_directory\subfolder\subfolder
-```
-
-### .opsprepare dotfile
-
-The prepare-content command uses `.opsprepare` dotfile as instruction set for content preparation.
-The syntax resembles that of `.gitignore` but differs in how it functions and doesn't support advanced
-pattern matching.
-
-Following operations/transformations are currently supported:
-
-- Copy: copies the file/directory from source path to destination path with same name
-- Transform: transform source file to destination file with same name
-- Removal: remove file/directory (based on source path) from destination path
-
-Before diving into the actual syntax and supported tokens let's look at an example
-of how using `ops prepare-content` creates a target directory structure with files
-based on the specified `.opsprepare` file residing in source directory.
-
-This is the example source directory structure:
-
-```ascii
-src_data
-├── .opsprepare
-├── README.tpl
-├── bin
-│   ├── ops.sh
-│   └── run
-│       └── ops
-├── dist
-│   └── server
-│       └── main.cs
-├── src
-│   ├── commands
-│   │   ├── prepare.ts
-│   │   └── version.ts
-│   ├── config.ts
-│   └── main.ts
-└── transform
-    └── render-tpl.js
-```
-
-Contents of `.opsprepare` file in the `src_data` directory:
-
-```txt
-# Comment
-src
-dist/server
-!src/commands
-!src/config.ts
-src/config.ts {cp:/src/configuration.ts}
-# Another comment
-!bin/run
-README.md {js:/transform/render-tpl.js:render}
-README.tpl {cp:/README.tpl.src}
-```
-
-Running `ops -s src_data -d dst_data` with `src_data/.opsprepare` containing above content
-results in:
-
-```ascii
-dst_data
-└── src_data
-    ├── README.md
-    ├── README.tpl.src
-    ├── dist
-    │   └── server
-    │       └── main.cs
-    └── src
-        ├── main.ts
-        └── src
-            └── configuration.ts
-```
-
-What actually happened:
-
-1. First note that all data was copied into `dst_data/src_data` because `.opsprepare` files relative
-   location to `ops` execution directiory is `src_data`.
-2. `src` directory was copied recursively to destination
-3. `dist/server` directory was copied recursively including its full path path relative to `src_data`
-4. `src/config.ts` file was transformed (copied) to `src/configuration.ts` in the destination
-5. `README.md` file was created at the destination as a result of JavaScript based transformation
-6. `README.tpl` file was transformed (copied) to `README.tpl.src` in the destination
-7. `src/commands` directory was removed from destination
-8. `src/config.ts` file was removed from destination
-9. `bin/run` directory was removed from destination
-
-Note that copying and explicit transformations are performed before any removal operations.
-
-#### Comments
-
-Any line prefixed by `#` is considered a comment and will not result in any file/directory operation.
-
-#### Copy operations
-
-Any file/directory not prefixed by `!` or `#` having explicit transformation defined in `{...}` after
-its name will be copied to the destination with it's full path relative to `ops` execution directory
-to the target directory.
-
-#### Transformation operations
-
-Transformation operations are always specified using curly braces following the source file name. Base
-syntax looks like this:
-
-```txt
-{<transformation type>:<transformation parameters>}
-```
-
-Two types of transformation operations are supported:
-
-- cp: copy transformation which supports renaming of the source file at the destination
-- js: JavasSript based transformation which results in the file containing string returned by the
-  transformation function contained in transformation module.
-
-**cp - copy transformation syntax**
-
-```txt
-{cp:<destination path>}
-
-Examples:
-{cp:/dst/newfilename}
-{cp:dst/newfilenames}
-```
-
-Copy transformation is supported for both files and directories. Source file or directory will be
-copied to the destination path with its new name. The destination will always be relative to the
-destination path of entire `prepare-content` operation therefore paths in the transformation block
-can start with or without the `/` character but using makes the syntax more readable.
-
-**js - JavaScript transformation syntax**
-
-```txt
-{js:<transformation_module_path>:<transformation_function_name>}
-
-Example:
-{js:/transformations/templateRenderer.js:renderEjsTemplate}
-```
-
-JavaScript transformation is supported only for files, not directories.
-
-Transformation module path should be relative to `.opsprepare` file but can start with `/` character
-for better readability. It can export multiple functions though only one can be used in single
-transformation specification.
-
-Transformation function that is defined in the transformation module will be called with a single
-parameter - absolute path of the source file.
-
-Transformation function MUST return a string. This string will become the content of the file on
-destination.
-
-Destination file will be created with the same name as source file and content returned by the
-transformation function. The existence of actual source file will not be validated by the
-`prepare-content` operation (warning is shown if it doesn't exist), such validation is responsibility
-of the transformation function if required.
-
-Example transformation module `transform.js` with exported function called transform:
-
-```js
-module.exports = {
-    render: (path) => {
-        /*
-        Some transformation happens in here and it's result which is
-        a string is assigned to result variable which is returned.
-        */
-        return result;
-    }
-}
-```
-
-#### Removal operations
-
-Any file/directory prefixed by `!` will be removed from the destination based on it's full path
-relative from `ops` execution directory to source file/directory path.
-
 ## `ops version <type>`
 
 creates everything necessary for the new release

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --trace-warnings "%~dp0\dev.js" %*

package/bin/dev.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env ts-node
+// eslint-disable-next-line node/shebang, unicorn/prefer-top-level-await
+(async () => {
+    const oclif = await import('@oclif/core');
+    await oclif.execute({ type: 'esm', development: true, dir: import.meta.url });
+})();

package/bin/run.cmd

@@ -1,3 +1,3 @@
 @echo off
 
-node "%~dp0\run" %*
+ts-node-esm "%~dp0\run.js" %*

package/bin/run.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// eslint-disable-next-line node/shebang
+import oclif from '@oclif/core';
+
+/* eslint-disable unicorn/prefer-top-level-await */
+oclif.run(process.argv.slice(2), import.meta.url)
+    .then(oclif.flush)
+    .catch(oclif.Errors.handle);

package/lib/command.base.d.ts

@@ -1,17 +1,21 @@
-import { Command } from '@oclif/command';
-import { IConfig } from '@oclif/config';
-import SecurityContext from './security/context';
-export default abstract class CommandBase extends Command {
+import { Command, Config } from '@oclif/core';
+import SecurityContext from './security/context.js';
+export default abstract class CommandBase<T extends typeof Command> extends Command {
     protected readonly security: SecurityContext;
-    constructor(argv: string[], config: IConfig);
+    constructor(argv: string[], config: Config);
     getGitRoot(startDir?: string): Promise<string>;
     getVersion(versionFile?: string, ...filesToCheck: string[]): Promise<string>;
     /**
      * Resolve path to Changelog folder from current execution directory
+     * @returns {string} the resolved path to changelogs
      */
     getChangelogsRoot(): Promise<string>;
     /**
      * Get all files inside directory and normalize it against {baseRelativePath}.
+     * @param {string} dir The name or path of the current directory
+     * @param {string} baseRelativePath The relatice path format from the `dir`
+     * @param {RegExp} filter Regular expressions filter for the file path
+     * @returns {string[]} An array of files inside the directory with the specified filter
      */
     getFilesRecursive(dir: string, baseRelativePath: string, filter: RegExp): Promise<string[]>;
 }

package/lib/command.base.jira.d.ts

@@ -1,11 +1,10 @@
-import { flags } from '@oclif/command';
-import JiraApi = require('jira-client');
-import CommandBase from './command.base';
-export default abstract class CommandBaseJira extends CommandBase {
+import JiraApi from 'jira-client';
+import CommandBase from './command.base.js';
+export default abstract class CommandBaseJira extends CommandBase<typeof CommandBaseJira> {
     static flags: {
-        username: flags.IOptionFlag<string>;
-        password: flags.IOptionFlag<string>;
-        hostname: flags.IOptionFlag<string>;
+        username: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        password: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        hostname: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
-    jiraInit(url: string, username: string, password: string): Promise<JiraApi>;
+    jiraInit(urlString: string, username: string, password: string): Promise<JiraApi>;
 }

package/lib/command.base.jira.js

@@ -1,37 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const JiraApi = require("jira-client");
-const command_base_1 = require("./command.base");
-class CommandBaseJira extends command_base_1.default {
-    async jiraInit(url, username, password) {
-        const jiraUrl = new URL(url);
-        const jira = new JiraApi({
-            protocol: jiraUrl.protocol,
-            host: jiraUrl.hostname,
-            username,
-            password,
-            apiVersion: '2',
-            strictSSL: true
+import { __awaiter } from "tslib";
+import { Flags } from '@oclif/core';
+import JiraApi from 'jira-client';
+import url from 'url';
+import CommandBase from './command.base.js';
+class CommandBaseJira extends CommandBase {
+    jiraInit(urlString, username, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const jiraUrl = new url.URL(urlString);
+            const jira = new JiraApi({
+                protocol: jiraUrl.protocol,
+                host: jiraUrl.hostname,
+                username,
+                password,
+                apiVersion: '2',
+                strictSSL: true,
+            });
+            return jira;
         });
-        return jira;
     }
 }
-exports.default = CommandBaseJira;
 CommandBaseJira.flags = {
-    username: command_1.flags.string({
+    username: Flags.string({
         description: 'jira username',
         env: 'JIRA_USERNAME',
-        required: true
+        required: true,
     }),
-    password: command_1.flags.string({
+    password: Flags.string({
         description: 'jira password',
         env: 'JIRA_PASSWORD',
-        required: true
+        required: true,
     }),
-    hostname: command_1.flags.string({
+    hostname: Flags.string({
         description: 'jira hostname',
         default: 'https://jira.adacta-fintech.com',
-        env: 'JIRA_HOSTNAME'
-    })
+        env: 'JIRA_HOSTNAME',
+    }),
 };
+export default CommandBaseJira;

package/lib/command.base.js

@@ -1,73 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const fs = require("fs-extra");
-const path = require("path");
-const context_1 = require("./security/context");
-class CommandBase extends command_1.Command {
+import { __awaiter } from "tslib";
+import { Command } from '@oclif/core';
+import fs from 'fs-extra';
+import path from 'path';
+import SecurityContext from './security/context.js';
+/* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+export default class CommandBase extends Command {
     constructor(argv, config) {
         super(argv, config);
-        this.security = new context_1.default(this.config.configDir);
+        this.security = new SecurityContext(this.config.configDir);
     }
-    async getGitRoot(startDir) {
-        let currentPath = path.resolve(startDir || process.cwd());
-        // tslint:disable-next-line: no-constant-condition
-        while (true) {
-            // We've reached the root and didn't find .git
-            if (currentPath === path.parse(currentPath).root) {
-                throw new Error('Not a git repository (or any of the parent directories)');
+    getGitRoot(startDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let currentPath = path.resolve(startDir !== null && startDir !== void 0 ? startDir : process.cwd());
+            /* eslint-disable-next-line no-constant-condition */
+            while (true) {
+                // We've reached the root and didn't find .git
+                if (currentPath === path.parse(currentPath).root) {
+                    throw new Error('Not a git repository (or any of the parent directories)');
+                }
+                if (yield fs.pathExists(path.resolve(currentPath, '.git'))) {
+                    // toLowerCase because of different behaviour when executing tests with yarn or with Test Explorer in VS Code
+                    return currentPath.toLowerCase();
+                }
+                currentPath = path.dirname(currentPath);
             }
-            if (await fs.pathExists(path.resolve(currentPath, '.git'))) {
-                // toLowerCase because of different behaviour when executing tests with yarn or with Test Explorer in VS Code
-                return currentPath.toLowerCase();
-            }
-            currentPath = path.dirname(currentPath);
-        }
+        });
     }
-    async getVersion(versionFile = 'VERSION', ...filesToCheck) {
-        filesToCheck.unshift(versionFile);
-        const gitRoot = await this.getGitRoot();
-        for (const file of filesToCheck) {
-            const versionPath = path.resolve(gitRoot, file);
-            if (await fs.pathExists(versionPath)) {
-                return fs.readFileSync(versionPath, 'utf-8').trim();
+    getVersion(versionFile = 'VERSION', ...filesToCheck) {
+        return __awaiter(this, void 0, void 0, function* () {
+            filesToCheck.unshift(versionFile);
+            const gitRoot = yield this.getGitRoot();
+            for (const file of filesToCheck) {
+                const versionPath = path.resolve(gitRoot, file);
+                if (yield fs.pathExists(versionPath)) {
+                    return fs.readFileSync(versionPath, 'utf8').trim();
+                }
             }
-        }
-        return this.error(`${filesToCheck} file was not found`, { exit: 2 });
+            return this.error(`${filesToCheck} file was not found`, { exit: 2 });
+        });
     }
     /**
      * Resolve path to Changelog folder from current execution directory
+     * @returns {string} the resolved path to changelogs
      */
-    async getChangelogsRoot() {
-        let currentPath = path.resolve(process.cwd());
-        if (!await fs.pathExists(currentPath)) {
-            this.log(`Directory '${currentPath}' doesn't exist ... nothing to do here.`);
-            this.exit(0);
-        }
-        return path.resolve(currentPath, 'changelogs', 'unreleased');
+    getChangelogsRoot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentPath = path.resolve(process.cwd());
+            if (!(yield fs.pathExists(currentPath))) {
+                this.log(`Directory '${currentPath}' doesn't exist ... nothing to do here.`);
+                this.exit(0);
+            }
+            return path.resolve(currentPath, 'changelogs', 'unreleased');
+        });
     }
     /**
      * Get all files inside directory and normalize it against {baseRelativePath}.
+     * @param {string} dir The name or path of the current directory
+     * @param {string} baseRelativePath The relatice path format from the `dir`
+     * @param {RegExp} filter Regular expressions filter for the file path
+     * @returns {string[]} An array of files inside the directory with the specified filter
      */
-    async getFilesRecursive(dir, baseRelativePath, filter) {
-        if (!await fs.pathExists(dir)) {
-            this.warn(`Directory '${dir}' doesn't exist ... nothing to do here.`);
-            return [];
-        }
-        let relativePath = path.relative(baseRelativePath, dir);
-        relativePath = relativePath === '' ? '.' : relativePath;
-        const entries = await fs.readdir(dir);
-        // Get files within the current directory and add a relative path to the file objects
-        const files = entries
-            .filter(file => !fs.statSync(path.resolve(dir, file)).isDirectory())
-            .filter(file => filter.test(path.resolve(dir, file)))
-            .map(file => `${relativePath}/${file}`);
-        // Get folders within the current directory
-        const folders = entries.filter(filetype => fs.statSync(path.resolve(dir, filetype)).isDirectory());
-        for (const folder of folders)
-            // Recursivly call this function and get relative paths of files inside directory
-            files.push(...await this.getFilesRecursive(path.join(dir, folder), baseRelativePath, filter));
-        return files;
+    getFilesRecursive(dir, baseRelativePath, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield fs.pathExists(dir))) {
+                this.warn(`Directory '${dir}' doesn't exist ... nothing to do here.`);
+                return [];
+            }
+            let relativePath = path.relative(baseRelativePath, dir);
+            relativePath = relativePath === '' ? '.' : relativePath;
+            const entries = yield fs.readdir(dir);
+            // Get files within the current directory and add a relative path to the file objects
+            const files = entries
+                .filter(file => !fs.statSync(path.resolve(dir, file)).isDirectory())
+                .filter(file => filter.test(path.resolve(dir, file)))
+                .map(file => `${relativePath}/${file}`);
+            // Get folders within the current directory
+            const folders = entries.filter(filetype => fs.statSync(path.resolve(dir, filetype)).isDirectory());
+            for (const folder of folders)
+                // Recursivly call this function and get relative paths of files inside directory
+                files.push(...yield this.getFilesRecursive(path.join(dir, folder), baseRelativePath, filter));
+            return files;
+        });
     }
 }
-exports.default = CommandBase;

package/lib/commands/docker/update-image-version.d.ts

@@ -1,17 +1,14 @@
-import { flags } from '@oclif/command';
-import CommandBase from '../../command.base';
-export default class DockerUpdateImageVersion extends CommandBase {
+import CommandBase from '../../command.base.js';
+export default class DockerUpdateImageVersion extends CommandBase<typeof DockerUpdateImageVersion> {
     static description: string;
     static usage: string;
     static examples: string[];
     static args: {
-        name: string;
-        description: string;
-        required: boolean;
-    }[];
+        version: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
     static flags: {
-        services: flags.IOptionFlag<string[]>;
-        'file-path': flags.IOptionFlag<string>;
+        services: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'file-path': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/lib/commands/docker/update-image-version.js

@@ -1,47 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-const fs = require("fs-extra");
-const yaml_1 = require("yaml");
-const command_base_1 = require("../../command.base");
-class DockerUpdateImageVersion extends command_base_1.default {
-    async run() {
-        const { args, flags } = this.parse(DockerUpdateImageVersion);
-        try {
-            let parsedYaml = yaml_1.parse(fs.readFileSync(flags['file-path'], 'utf8'));
-            for (let service of flags.services) {
-                let image = parsedYaml.services[service].image.split(':');
-                image[1] = args.version;
-                parsedYaml.services[service].image = image.join(':');
+import { __awaiter } from "tslib";
+import { Args, Flags } from '@oclif/core';
+import fs from 'fs-extra';
+import { parse as yamlParse, stringify as yamlStringify } from 'yaml';
+import CommandBase from '../../command.base.js';
+class DockerUpdateImageVersion extends CommandBase {
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args, flags } = yield this.parse(DockerUpdateImageVersion);
+            try {
+                const parsedYaml = yamlParse(fs.readFileSync(flags['file-path'], 'utf8'));
+                for (const service of flags.services) {
+                    const image = parsedYaml.services[service].image.split(':');
+                    image[1] = args.version;
+                    parsedYaml.services[service].image = image.join(':');
+                }
+                fs.writeFileSync(flags['file-path'], yamlStringify(parsedYaml));
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
-            fs.writeFileSync(flags['file-path'], yaml_1.stringify(parsedYaml));
-        }
-        catch (err) {
-            this.error(err.message);
-        }
+            catch (error) {
+                this.error(error.message);
+            }
+        });
     }
 }
-exports.default = DockerUpdateImageVersion;
 DockerUpdateImageVersion.description = 'update docker image version docker compose file';
 DockerUpdateImageVersion.usage = 'docker:update-image-version <tag>';
 DockerUpdateImageVersion.examples = [
-    `$ ops docker:update-image-version 17.0.0 --service server client`
-];
-DockerUpdateImageVersion.args = [
-    {
-        name: 'version',
-        description: 'version',
-        required: true
-    }
+    `$ ops docker:update-image-version 17.0.0 --service server client`,
 ];
+DockerUpdateImageVersion.args = {
+    version: Args.string({
+        required: true,
+        description: 'Version',
+    }),
+};
 DockerUpdateImageVersion.flags = {
-    services: command_1.flags.string({
+    services: Flags.string({
         required: true,
         description: 'list of services to update',
-        multiple: true
+        multiple: true,
     }),
-    'file-path': command_1.flags.string({
+    'file-path': Flags.string({
         default: './docker-compose.yml',
-        description: 'list of services to update'
-    })
+        description: 'list of services to update',
+    }),
 };
+export default DockerUpdateImageVersion;