cron-converter-u2q 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Rahul
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# cron-converter-u2q
+Easily convert cron expressions between Unix and Quartz formats with the `cron-converter-u2q` package
+
+
+
+### Features
+
+:arrows_counterclockwise: Two-way conversion: from Unix to Quartz and Quartz to Unix.
+
+:zap: Lightweight.
+
+### Installation
+
+Using npm:
+
+```bash
+npm install cron-converter
+```
+
+Using yarn:
+
+```bash
+yarn add cron-converter
+```
+
+### Usage
+Firstly, import the CronConverterU2Q module:
+```javascript
+import { CronConverterU2Q as c2q } from 'cron-converter';
+```
+
+If you're using ES6 Modules
+```javascript
+import { CronConverterU2Q as c2q } from 'cron-converter';
+```
+Convert from Unix to Quartz
+```javascript
+const quartzExpression = c2q.unixToQuartz('5 * * * *');
+```
+Convert from Quartz to Unix
+```javascript
+const unixExpression = c2q.quartzToUnix('* */5 * ? * * *');
+```
+
+### Development Notice
+This package is still under active development. Some methods and features might not be stable yet. We're working diligently to improve and stabilize the package. Any feedback, suggestions, or contributions are highly appreciated!
+
+## License
+
+This project is licensed under the [MIT License](https://opensource.org/license/mit/)
+

package/jest.config.ts

@@ -0,0 +1,10 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    roots: ['./src/'],
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest'
+    },
+    testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
+    moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+};

package/lib/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronConverterU2Q = void 0;
+class CronConverterU2Q {
+    constructor() {
+        this.delimiter = ' ';
+        this.unixExpressionLength = 5;
+        this.quartzExpressionLengths = [6, 7];
+    }
+    /**
+     * Converts a unix cron expression to a quartz cron expression by adding '0' seconds
+     * @param unixExpression - the unix expression
+     * @returns the corresponding quartz expression
+     */
+    unixToQuartz(unixExpression) {
+        this.validateIfNullOrEmpty(unixExpression);
+        const parts = unixExpression.split(this.delimiter);
+        if (parts.length !== this.unixExpressionLength)
+            throw new Error(`Invalid unix cron format`);
+        const [min, hour, dom, month, dow] = parts;
+        let quartzDom = dom;
+        let quartzDow = dow;
+        if (dom === '*' && (dow === '*' || dow !== '*'))
+            quartzDom = '?';
+        else if (dom !== '*' && dow === '*')
+            quartzDow = '?';
+        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow}`;
+    }
+    /**
+     * Converts a quartz cron expression to a unix cron expression
+     * @param quartzExpression - the quartz expression
+     * @returns the corresponding unix expression
+     */
+    quartzToUnix(quartzExpression) {
+        this.validateIfNullOrEmpty(quartzExpression);
+        const parts = quartzExpression.split(this.delimiter);
+        if (!this.quartzExpressionLengths.includes(parts.length))
+            throw new Error(`Invalid quartz cron format`);
+        const [_, min, hour, dom, month, dow] = parts;
+        let unixDom = dom;
+        let unixDow = dow;
+        if (dom === '?' && dow === '*')
+            unixDom = '*';
+        else if (dow === '?' && dom === '*')
+            unixDow = '*';
+        else if (dom !== '?' && dom === '?')
+            unixDom = '*';
+        return `${min} ${hour} ${unixDom} ${month} ${unixDow}`;
+    }
+    validateIfNullOrEmpty(cronExpression) {
+        if (!cronExpression || cronExpression.trim() === '')
+            throw new Error('Empty or null expression');
+    }
+}
+exports.CronConverterU2Q = CronConverterU2Q;
+// if (process.env.NODE_ENV === 'development') {
+// }

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "cron-converter-u2q",
+  "version": "0.1.3",
+  "description": "Converts cron expressions between unix and quartz formats",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --no-watchman --coverage"
+  },
+  "author": "BitBundler <rahu619@gmail.com>",
+  "keywords": [
+    "cron",
+    "unix",
+    "quartz",
+    "cron-expression",
+    "cron-convert"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.3",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^20.4.9",
+    "jest": "^29.6.2",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
+  }
+}

package/src/__tests__/index.test.ts

@@ -0,0 +1,24 @@
+import { CronConverterU2Q as c2q } from '../index';
+
+//Basic suite of tests
+describe('Unix2Quartz Conversion', () => {
+
+    test('unixToQuartz conversion', () => {
+        const result = c2q.unixToQuartz('*/5 * * * *'); //Every 5 minutes
+        expect(result).toBe("0 */5 * ? * *");
+    });
+
+    test('unixToQuartz conversion', () => {
+        const result = c2q.unixToQuartz('0 12 * * *'); //Everyday at 12pm
+        expect(result).toBe("0 0 12 ? * *");
+    });
+});
+
+
+describe('Quartz2Unix Conversion', () => {
+
+    test('quartzToUnix conversion', () => {
+        const result = c2q.quartzToUnix('* */5 * ? * * *'); //Every 5 minutes
+        expect(result).toBe("*/5 * * * *");
+    });
+});

package/src/index.ts

@@ -0,0 +1,64 @@
+export class CronConverterU2Q {
+
+    static readonly delimiter = ' ';
+    static readonly unixExpressionLength = 5;
+    static readonly quartzExpressionLengths = [6, 7];
+
+    /**
+     * Converts a unix cron expression to a quartz cron expression by adding '0' seconds
+     * @param unixExpression - the unix expression
+     * @returns the corresponding quartz expression
+     */
+    public static unixToQuartz(unixExpression: string): string {
+
+        this.validateIfNullOrEmpty(unixExpression);
+
+        const parts = unixExpression.split(this.delimiter);
+        if (parts.length !== this.unixExpressionLength) throw new Error(`Invalid unix cron format`);
+
+        const [min, hour, dom, month, dow] = parts;
+        let quartzDom = dom;
+        let quartzDow = dow;
+
+        if (dom === '*' && (dow === '*' || dow !== '*')) quartzDom = '?';
+        else if (dom !== '*' && dow === '*') quartzDow = '?';
+
+        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow}`;
+    }
+
+    /**
+     * Converts a quartz cron expression to a unix cron expression
+     * @param quartzExpression - the quartz expression
+     * @returns the corresponding unix expression
+     */
+    public static quartzToUnix(quartzExpression: string): string {
+
+        this.validateIfNullOrEmpty(quartzExpression);
+
+        const parts = quartzExpression.split(this.delimiter);
+
+        if (!this.quartzExpressionLengths.includes(parts.length)) throw new Error(`Invalid quartz cron format`);
+
+        const [_, min, hour, dom, month, dow] = parts;
+        let unixDom = dom;
+        let unixDow = dow;
+
+        if (dom === '?' && dow === '*') unixDom = '*';
+        else if (dow === '?' && dom === '*') unixDow = '*';
+        else if (dom !== '?' && dom === '?') unixDom = '*';
+
+        return `${min} ${hour} ${unixDom} ${month} ${unixDow}`;
+    }
+
+    private static validateIfNullOrEmpty(cronExpression: string | undefined | null): void {
+        if (!cronExpression || cronExpression.trim() === '') throw new Error('Empty or null expression');
+    }
+
+}
+
+export const CronConverterU2QModule = CronConverterU2Q;
+
+
+// if (process.env.NODE_ENV === 'development') {
+// }
+

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    /* Language and Environment */
+    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "module": "commonjs" /* Specify what module code is generated. */,
+    "outDir": "./lib" /* Specify an output folder for all emitted files. */,
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "**/__tests__/**"]
+}

package/types/index.d.ts

@@ -0,0 +1,6 @@
+declare module 'cron-converter-u2q' {
+    export const CronConverterU2QModule: {
+        unixToQuartz(unixExpression: string): string;
+        quartzToUnix(quartzExpression: string): string;
+    }
+}