@grnsft/if 0.3.1 → 0.3.3-beta.0

package/build/util/helpers.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeObjects = exports.andHandle = void 0;
+exports.execPromise = exports.mergeObjects = exports.andHandle = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
 const errors_1 = require("./errors");
-const config_1 = require("../config");
 const logger_1 = require("./logger");
+const config_1 = require("../config");
 const { ISSUE_TEMPLATE } = config_1.STRINGS;
 /**
  * Impact engine error handler. Logs errors and appends issue template if error is unknown.
@@ -17,21 +19,23 @@ const andHandle = (error) => {
 };
 exports.andHandle = andHandle;
 /**
- * Mergers two objects, omitting null values.
+ * Append entries from defaults which are missing from inputs.
  */
-const mergeObjects = (object1, object2) => {
-    const merged = {};
-    const keys1 = Object.keys(object1);
-    keys1.forEach(key1 => {
-        merged[key1] = object1[key1] || object2[key1];
-    });
-    const keys2 = Object.keys(object2);
-    keys2.forEach(key2 => {
-        if (!keys1.includes(key2)) {
-            merged[key2] = object2[key2];
+const mergeObjects = (defaults, input) => {
+    const merged = structuredClone(input);
+    for (const key in defaults) {
+        if (!(key in input)) {
+            merged[key] = defaults[key];
+        }
+        if (merged[key] === undefined || merged[key] === null) {
+            merged[key] = defaults[key];
         }
-    });
+    }
     return merged;
 };
 exports.mergeObjects = mergeObjects;
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Promise version of Node's `exec` from `child-process`.
+ */
+exports.execPromise = (0, node_util_1.promisify)(node_child_process_1.exec);
+//# sourceMappingURL=data:application/json;base64,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

package/build/util/os-checker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Finds operating system information like name and version.
+ */
+export declare const osInfo: () => Promise<{
+    os: string;
+    'os-version': string;
+}>;

package/build/util/os-checker.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.osInfo = void 0;
+const os_1 = require("os");
+const helpers_1 = require("./helpers");
+/**
+ * Executes `lsb_release -a` command in terminal.
+ *
+ * ```
+ * Distributor ID: Ubuntu
+ * Description:    Ubuntu 22.04.4 LTS
+ * Release:        22.04
+ * Codename:       jammy
+ * ```
+ *
+ * Parses os and os-version from the response.
+ */
+const getLinuxInfo = async () => {
+    const { stdout } = await (0, helpers_1.execPromise)('lsb_release -a');
+    const parseLinuxVersion = (lsbReleaseResponse) => {
+        const regex = /Distributor ID: ([^\n]+)\nDescription: +([^ ]+) +([^ ]+) +(.+)\n/;
+        const match = lsbReleaseResponse.match(regex);
+        return {
+            os: match ? match[1] : (0, os_1.platform)(),
+            'os-version': match ? `${match[3]} ${match[4]}` : (0, os_1.release)(),
+        };
+    };
+    return parseLinuxVersion(stdout);
+};
+/**
+ * Executes in CMD `systeminfo | findstr /B /C:"OS Name" /B /C:"OS Version"` command.
+ *
+ * ```
+ * OS Name:                   Microsoft Windows 11 Enterprise
+ * OS Version:                10.0.22631 N/A Build 22631
+ * ```
+ *
+ * Parses os and os-version from the response.
+ */
+const getWindowsInfo = async () => {
+    const { stdout } = await (0, helpers_1.execPromise)('systeminfo | findstr /B /C:"OS Name" /B /C:"OS Version"');
+    const parseWindowsInfo = (systemInfoResponse) => {
+        const regex = /OS Name:\s+([^\n]+)\nOS Version:\s+([\d.]+)\s+(N\/A\s+Build\s+(\d+))/;
+        const match = systemInfoResponse.match(regex);
+        return {
+            os: match ? match[1] : (0, os_1.platform)(),
+            'os-version': match ? `${match[2]} ${match[3]}` : (0, os_1.release)(),
+        };
+    };
+    return parseWindowsInfo(stdout);
+};
+/**
+ * Executes `sw_vers` command in terminal.
+ *
+ * ```
+ * ProductName:      macOS
+ * ProductVersion:   14.3.1
+ * BuildVersion:     23D60
+ * ```
+ *
+ * Parses os and os version from the response.
+ */
+const getMacVersion = async () => {
+    const { stdout } = await (0, helpers_1.execPromise)('sw_vers');
+    const parseMacInfo = (swVersResponse) => {
+        const productNameRegex = /ProductName:\s*(.+)/;
+        const productVersionRegex = /ProductVersion:\s*(.+)/;
+        const nameMatch = swVersResponse.match(productNameRegex);
+        const versionMatch = swVersResponse.match(productVersionRegex);
+        return {
+            os: nameMatch ? nameMatch[1].trim() : (0, os_1.platform)(),
+            'os-version': versionMatch ? versionMatch[1].trim() : (0, os_1.release)(),
+        };
+    };
+    return parseMacInfo(stdout);
+};
+/**
+ * Finds operating system information like name and version.
+ */
+const osInfo = async () => {
+    const osKind = (0, os_1.platform)();
+    switch (osKind) {
+        case 'darwin':
+            return getMacVersion();
+        case 'linux':
+            return getLinuxInfo();
+        case 'win32':
+            return getWindowsInfo();
+        default:
+            return {
+                os: osKind,
+                'os-version': (0, os_1.release)(),
+            };
+    }
+};
+exports.osInfo = osInfo;
+//# sourceMappingURL=data:application/json;base64,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

package/build/util/validations.d.ts

@@ -74,8 +74,58 @@ export declare const manifestSchema: z.ZodObject<{
         }>;
         outputs?: string[] | undefined;
     }>;
+    execution: z.ZodObject<{
+        command: z.ZodString;
+        environment: z.ZodObject<{
+            'if-version': z.ZodString;
+            os: z.ZodString;
+            'os-version': z.ZodString;
+            'node-version': z.ZodString;
+            'date-time': z.ZodString;
+            dependencies: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        }, {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        }>;
+        status: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        command: string;
+        environment: {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        };
+        error?: string | undefined;
+    }, {
+        status: string;
+        command: string;
+        environment: {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        };
+        error?: string | undefined;
+    }>;
     tree: z.ZodRecord<z.ZodString, z.ZodAny>;
-    'if-version': z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     initialize: {
@@ -86,6 +136,19 @@ export declare const manifestSchema: z.ZodObject<{
         }>;
         outputs?: string[] | undefined;
     };
+    execution: {
+        status: string;
+        command: string;
+        environment: {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        };
+        error?: string | undefined;
+    };
     tree: Record<string, any>;
     description?: string | null | undefined;
     tags?: {
@@ -103,7 +166,6 @@ export declare const manifestSchema: z.ZodObject<{
         aggregation: "sum" | "none" | "avg";
         unit: string;
     }[] | null | undefined;
-    'if-version'?: string | null | undefined;
 }, {
     name: string;
     initialize: {
@@ -114,6 +176,19 @@ export declare const manifestSchema: z.ZodObject<{
         }>;
         outputs?: string[] | undefined;
     };
+    execution: {
+        status: string;
+        command: string;
+        environment: {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        };
+        error?: string | undefined;
+    };
     tree: Record<string, any>;
     description?: string | null | undefined;
     tags?: {
@@ -131,7 +206,6 @@ export declare const manifestSchema: z.ZodObject<{
         aggregation: "sum" | "none" | "avg";
         unit: string;
     }[] | null | undefined;
-    'if-version'?: string | null | undefined;
 }>;
 /**
  * Validates given `manifest` object to match pattern.
@@ -146,6 +220,19 @@ export declare const validateManifest: (manifest: any) => {
         }>;
         outputs?: string[] | undefined;
     };
+    execution: {
+        status: string;
+        command: string;
+        environment: {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        };
+        error?: string | undefined;
+    };
     tree: Record<string, any>;
     description?: string | null | undefined;
     tags?: {
@@ -163,7 +250,6 @@ export declare const validateManifest: (manifest: any) => {
         aggregation: "sum" | "none" | "avg";
         unit: string;
     }[] | null | undefined;
-    'if-version'?: string | null | undefined;
 };
 /**
  * Validates given `object` with given `schema`.

package/build/util/validations.js

@@ -44,8 +44,20 @@ exports.manifestSchema = zod_1.z.object({
         })),
         outputs: zod_1.z.array(zod_1.z.string()).optional(),
     }),
+    execution: zod_1.z.object({
+        command: zod_1.z.string(),
+        environment: zod_1.z.object({
+            'if-version': zod_1.z.string(),
+            os: zod_1.z.string(),
+            'os-version': zod_1.z.string(),
+            'node-version': zod_1.z.string(),
+            'date-time': zod_1.z.string(),
+            dependencies: zod_1.z.array(zod_1.z.string()),
+        }),
+        status: zod_1.z.string(),
+        error: zod_1.z.string().optional(),
+    }),
     tree: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
-    'if-version': zod_1.z.string().optional().nullable(),
 });
 /**
  * Validates given `manifest` object to match pattern.
@@ -78,4 +90,4 @@ const prettifyErrorMessage = (issues) => {
         return `"${fullPath}" parameter is ${message.toLowerCase()}. Error code: ${code}.`;
     });
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validations.js","sourceRoot":"","sources":["../../src/util/validations.ts"],"names":[],"mappings":"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","sourcesContent":["import {ZodIssue, ZodSchema, z} from 'zod';\n\nimport {ERRORS} from './errors';\n\nimport {AGGREGATION_METHODS} from '../types/aggregation';\nimport {AGGREGATION_TYPES} from '../types/parameters';\n\nconst {ManifestValidationError, InputValidationError} = ERRORS;\n\n/**\n * Validation schema for manifests.\n */\nexport const manifestSchema = z.object({\n  name: z.string(),\n  description: z.string().optional().nullable(),\n  tags: z\n    .object({\n      kind: z.string().optional().nullable(),\n      complexity: z.string().optional().nullable(),\n      category: z.string().optional().nullable(),\n    })\n    .optional()\n    .nullable(),\n  aggregation: z\n    .object({\n      metrics: z.array(z.string()),\n      type: z.enum(AGGREGATION_METHODS),\n    })\n    .optional()\n    .nullable(),\n  params: z\n    .array(\n      z.object({\n        name: z.string(),\n        description: z.string(),\n        aggregation: z.enum(AGGREGATION_TYPES),\n        unit: z.string(),\n      })\n    )\n    .optional()\n    .nullable(),\n  initialize: z.object({\n    plugins: z.record(\n      z.string(),\n      z.object({\n        path: z.string(),\n        method: z.string(),\n        'global-config': z.record(z.string(), z.any()).optional(),\n      })\n    ),\n    outputs: z.array(z.string()).optional(),\n  }),\n  execution: z.object({\n    command: z.string(),\n    environment: z.object({\n      'if-version': z.string(),\n      os: z.string(),\n      'os-version': z.string(),\n      'node-version': z.string(),\n      'date-time': z.string(),\n      dependencies: z.array(z.string()),\n    }),\n    status: z.string(),\n    error: z.string().optional(),\n  }),\n  tree: z.record(z.string(), z.any()),\n});\n\n/**\n * Validates given `manifest` object to match pattern.\n */\nexport const validateManifest = (manifest: any) =>\n  validate(manifestSchema, manifest, ManifestValidationError);\n\n/**\n * Validates given `object` with given `schema`.\n */\nexport const validate = <T>(\n  schema: ZodSchema<T>,\n  object: any,\n  errorConstructor: ErrorConstructor = InputValidationError\n) => {\n  const validationResult = schema.safeParse(object);\n\n  if (!validationResult.success) {\n    throw new errorConstructor(\n      prettifyErrorMessage(validationResult.error.message)\n    );\n  }\n\n  return validationResult.data;\n};\n\n/**\n * Beautify error message from zod issue.\n */\nconst prettifyErrorMessage = (issues: string) => {\n  const issuesArray = JSON.parse(issues);\n\n  return issuesArray.map((issue: ZodIssue) => {\n    const {code, path, message} = issue;\n    const flattenPath = path.map(part =>\n      typeof part === 'number' ? `[${part}]` : part\n    );\n    const fullPath = flattenPath.join('.');\n\n    if (code === 'custom') {\n      return `${message.toLowerCase()}. Error code: ${code}.`;\n    }\n\n    return `\"${fullPath}\" parameter is ${message.toLowerCase()}. Error code: ${code}.`;\n  });\n};\n"]}

package/github-processes.md

@@ -0,0 +1,168 @@
+
+## IF Repositories
+
+- [`if`](https://github.com/Green-Software-Foundation/if)
+    - source code for the IF
+- [`if-plugins`](https://github.com/Green-Software-Foundation/if-plugins)
+    - source code for standard library of plugins
+    - IF core team commit to maintaining these plugins 
+- [`if-unofficial-plugins`](https://github.com/Green-Software-Foundation/if-unofficial-plugins)
+    - source code for plugins relying on third-party data/APIs
+    - intended to be deprecated and removed in mid-term future
+    - plugins in this repo should be handed over to relevant organizations to maintain
+- [`if-plugin-template`](https://github.com/Green-Software-Foundation/if-plugin-template)
+    - template for new plugins
+    - intended for builders to bootstrap IF-compatible plugin development
+- [`if-standards`](https://github.com/Green-Software-Foundation/if-standards)
+    - not currently used, but intended to be the home of params.ts
+    - will have a dedicated discussion board and governance to set IF standards
+- [`if-exhaust plugins`](https://github.com/Green-Software-Foundation/if-exhaust-plugins)
+    - not currently used
+    - intended to become a separate repo just for exhaust plugins
+    - requires strict rules from if
+
+
+## Branch names and purposes
+
+Our main repositories all have two branches: `main` and `release`.
+Here are the rules applied to each branch:
+
+### `if`, `if-plugins`, `if-unofficial-plugins` and `if-exhaust-plugins`
+
+#### `main`
+- target branch for PRs
+- PRs can be merged into `main` with two core team reviews, one being QA
+- `main` regularly advances ahead of the `release` branch
+- merged into `release` periodically, only after full QA approval
+- pushing directly to `main` is forbidden - all changes are by PR
+- PRs will not be merged if they do not pass CI/CD
+
+#### `release`
+
+- release is our stable branch
+- it is protected and only merged into when we have a fully QA-approved `main` state that we want to release
+- npm packages are released using `release` branch
+- PRs into `release` are forbidden except to update tests, README, Github config, CI/CD or release config.
+- Pushing directly to `release` is forbidden
+- `release` should always satisfy a basic set of regression and scenario tests
+- merging `main` into `release` requires that all automated tests pass and two core team members have approved, one being QA.
+
+### `if-plugin-template` 
+
+- we only maintain a single branch: `main`
+- PRs to `main` can be merged after one approval from core team
+- Pushing directly to `main` is possible but discouraged
+
+
+### `if-docs`
+
+- we only maintain a single branch - `main`
+- PRs to `main` can be merged after one approval from core team
+- Pushing directly to `main` is possible but discouraged
+
+### When can we break our rules?
+
+- `release` branches have the strictest rules. We should never override the process outlined above for `release` branches in any repository.
+- On `main` we can be slightly more flexible. It is acceptable to skip QA for PRs that only change typos, documentation or comments. Any changes to source code or tests should be QA approved before merge.
+- In emergency scenarios where an urgent hotfix is required it might be required to skip QA review on `main` branches - this should only happen with QA authorization so QA can retroactively test as soon as possible.
+
+### How to create a release
+
+Creating a release of `if`, `if-plugins` or `if-unofficial-plugins` is achieved by following these steps:
+
+1) core team member creates a tagged release on `main`
+2) new tagged release triggers automatic commit to be pushed to `main` that updates package and lock files that include new version numbers
+3) `main` branch is manually merged into `release` by core team member
+4) merging into release triggers automatic new release to be created on npm
+
+We use [semantic versioning](https://semver.org/) to number our releases. 
+## DCO
+
+We require contributors to conform to the DCO agreement on our repositories. This means either signing commits or explicitly adding a DCO commit message. This ensures all contributors agree to the conditions imposed by our licenses and adhere to our expected practices. The DCO must be satisfied in order to PRs to be merged.
+
+## Commits
+
+Commits are expected to conform to the [conventional-commits](https://www.conventionalcommits.org/en/v1.0.0/) syntax.
+Commits are expected to be signed and have descriptive commit messages.
+We might ask people to provide new messages in some circumstances or to break their PRs into smaller logical units.
+
+## PR triage
+
+We run a weekly PR triage call on Thursdays. The most important outcome of this call is to examine open PRs and issues across all the IF repositories and determine which ones include changes that we might want to merge. This initial sift for changes that are or are not aligned with our goals for the IF should be prioritized above technical comments and fixes.
+
+Some reasons why a PR might not pass triage:
+
+- changes are not aligned with our vision for IF
+- we do not see a strong reason for making a change
+- changes are obviously technically incorrect
+- changes are too large to properly review (e.g. covering too many files)
+- too many changes are made in too few commits
+- commit messages are ambiguous
+- PR description is too short, vague or imprecise
+- PR would for some other reason take too long for core team to assess
+- PR makes changes that do not conform to our license
+- PR makes use of a third-party API or dataset in an illegitimate way (e.g. exposing data that should be paywalled)
+
+After a PR has passed triage, it can be assigned to a core team member to review. Developer review precedes QA review. Community PRs (PRs raised from outside the core team) will *always* go through a full QA vetting procedure before being merged.
+
+We intend to respond to new PRs and issues within 3 days of the ticket being opened, even if only with a brief message thanking the OP and explaining the triage process.
+
+
+## Labels
+
+```
+//review status labels 
+awaiting-triage 
+triage-pass 
+awaiting-review 
+review-pass 
+awaiting-qa 
+qa-pass 
+changes-needed 
+
+//change type labels 
+fix 
+feature 
+docs 
+package 
+other 
+
+// size labels 
+small 
+medium 
+large 
+
+// priority labels 
+high-priority 
+med-priority 
+low-priority 
+
+//delay explanation labels 
+abandoned 
+blocked 
+backlogged
+
+// other labels
+project-management
+agenda
+discussion
+help-wanted
+good-first-issue
+```
+
+Each PR is expected to have one label from each category (except `other`) assigned to it at all times.
+
+
+## Releases
+
+We aim to release fortnightly, every other Tuesday. We release npm packages for `if`, `if-plugins`, `if-unofficial-plugins`, and `if-plugin-template`.
+
+## Hotfixes
+
+We will hotfix by raising PRs into `release` when necessary. These PRs require sign-off by a core developer and our QA engineer. 
+
+If more than two hotfixes are required on a particular release, the team will call a spike meeting to determine the causes of the bugs, identify any changes required to our QA process and determine next steps for fixing the release. 
+
+Hotfixes on release can be merged back into `main` when they have been fully QA tested.
+
+We intend for hotfixes to be as infrequent as possible.