pepr 0.1.4 → 0.1.6

package/README.md

@@ -51,8 +51,7 @@ import "./test-mutations";
 ### demo/hello-world/index.ts
 
 ```typescript
-import { a } from "@k8s";
-import { Capability } from "@pepr";
+import { Capability, a } from "pepr";
 
 const { When } = new Capability({
   // The unique name of the capability

package/dist/pepr-20e17cf6-a2e4-46b2-b626-75d88d96c88b.js

@@ -0,0 +1,393 @@
+'use strict';
+
+require('@kubernetes/client-node/dist');
+var R = require('ramda');
+var fastJsonPatch = require('fast-json-patch');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
+
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["debug"] = 0] = "debug";
+    LogLevel[LogLevel["info"] = 1] = "info";
+    LogLevel[LogLevel["warn"] = 2] = "warn";
+    LogLevel[LogLevel["error"] = 3] = "error";
+})(LogLevel || (LogLevel = {}));
+var ConsoleColors;
+(function (ConsoleColors) {
+    ConsoleColors["Reset"] = "\u001B[0m";
+    ConsoleColors["Bright"] = "\u001B[1m";
+    ConsoleColors["Dim"] = "\u001B[2m";
+    ConsoleColors["Underscore"] = "\u001B[4m";
+    ConsoleColors["Blink"] = "\u001B[5m";
+    ConsoleColors["Reverse"] = "\u001B[7m";
+    ConsoleColors["Hidden"] = "\u001B[8m";
+    ConsoleColors["FgBlack"] = "\u001B[30m";
+    ConsoleColors["FgRed"] = "\u001B[31m";
+    ConsoleColors["FgGreen"] = "\u001B[32m";
+    ConsoleColors["FgYellow"] = "\u001B[33m";
+    ConsoleColors["FgBlue"] = "\u001B[34m";
+    ConsoleColors["FgMagenta"] = "\u001B[35m";
+    ConsoleColors["FgCyan"] = "\u001B[36m";
+    ConsoleColors["FgWhite"] = "\u001B[37m";
+    ConsoleColors["BgBlack"] = "\u001B[40m";
+    ConsoleColors["BgRed"] = "\u001B[41m";
+    ConsoleColors["BgGreen"] = "\u001B[42m";
+    ConsoleColors["BgYellow"] = "\u001B[43m";
+    ConsoleColors["BgBlue"] = "\u001B[44m";
+    ConsoleColors["BgMagenta"] = "\u001B[45m";
+    ConsoleColors["BgCyan"] = "\u001B[46m";
+    ConsoleColors["BgWhite"] = "\u001B[47m";
+})(ConsoleColors || (ConsoleColors = {}));
+class Logger {
+    constructor(logLevel) {
+        this._logLevel = logLevel;
+    }
+    SetLogLevel(logLevel) {
+        this._logLevel = LogLevel[logLevel];
+        this.debug(`Log level set to ${logLevel}`);
+    }
+    debug(message, prefix) {
+        this.log(LogLevel.debug, message, prefix);
+    }
+    info(message, prefix) {
+        this.log(LogLevel.info, message, prefix);
+    }
+    warn(message, prefix) {
+        this.log(LogLevel.warn, message, prefix);
+    }
+    error(message, prefix) {
+        this.log(LogLevel.error, message, prefix);
+    }
+    log(logLevel, message, callerPrefix = "") {
+        const color = {
+            [LogLevel.debug]: ConsoleColors.FgBlack,
+            [LogLevel.info]: ConsoleColors.FgCyan,
+            [LogLevel.warn]: ConsoleColors.FgYellow,
+            [LogLevel.error]: ConsoleColors.FgRed,
+        };
+        if (logLevel >= this._logLevel) {
+            let prefix = "[" + LogLevel[logLevel] + "]\t" + callerPrefix;
+            prefix = this.colorize(prefix, color[logLevel]);
+            if (typeof message !== "string") {
+                console.log(prefix);
+                console.debug("%o", message);
+            }
+            else {
+                console.log(prefix + "\t" + message);
+            }
+        }
+    }
+    colorize(text, color) {
+        return color + text + ConsoleColors.Reset;
+    }
+}
+var logger = new Logger(LogLevel.info);
+
+var Operation;
+(function (Operation) {
+    Operation["CREATE"] = "CREATE";
+    Operation["UPDATE"] = "UPDATE";
+    Operation["DELETE"] = "DELETE";
+    Operation["CONNECT"] = "CONNECT";
+})(Operation || (Operation = {}));
+
+var ErrorBehavior;
+(function (ErrorBehavior) {
+    ErrorBehavior["ignore"] = "ignore";
+    ErrorBehavior["audit"] = "audit";
+    ErrorBehavior["reject"] = "reject";
+})(ErrorBehavior || (ErrorBehavior = {}));
+var HookPhase;
+(function (HookPhase) {
+    HookPhase["mutate"] = "mutate";
+    HookPhase["valdiate"] = "validate";
+})(HookPhase || (HookPhase = {}));
+var Event;
+(function (Event) {
+    Event["Create"] = "create";
+    Event["Update"] = "update";
+    Event["Delete"] = "delete";
+    Event["CreateOrUpdate"] = "createOrUpdate";
+})(Event || (Event = {}));
+
+class RequestWrapper {
+    get PermitSideEffects() {
+        return !this._input.dryRun;
+    }
+    get IsDryRun() {
+        return this._input.dryRun;
+    }
+    get OldResource() {
+        return this._input.oldObject;
+    }
+    get Request() {
+        return this._input;
+    }
+    constructor(input) {
+        this.Raw = R__namespace.clone(input.object);
+        this._input = input;
+    }
+    Merge(obj) {
+        this.Raw = R__namespace.mergeDeepRight(this.Raw, obj);
+    }
+    SetLabel(key, value) {
+        const ref = this.Raw;
+        ref.metadata = ref.metadata ?? {};
+        ref.metadata.labels = ref.metadata.labels ?? {};
+        ref.metadata.labels[key] = value;
+        return this;
+    }
+    SetAnnotation(key, value) {
+        const ref = this.Raw;
+        ref.metadata = ref.metadata ?? {};
+        ref.metadata.annotations = ref.metadata.annotations ?? {};
+        ref.metadata.annotations[key] = value;
+        return this;
+    }
+    RemoveLabel(key) {
+        if (this.Raw.metadata?.labels?.[key]) {
+            delete this.Raw.metadata.labels[key];
+        }
+        return this;
+    }
+    RemoveAnnotation(key) {
+        if (this.Raw.metadata?.annotations?.[key]) {
+            delete this.Raw.metadata.annotations[key];
+        }
+        return this;
+    }
+    HasLabel(key) {
+        return this.Raw?.metadata?.labels?.[key] !== undefined;
+    }
+    HasAnnotation(key) {
+        return this.Raw?.metadata?.annotations?.[key] !== undefined;
+    }
+}
+
+function shouldSkipRequest(binding, req) {
+    const { group, kind, version } = binding.kind;
+    const { namespaces, labels, annotations } = binding.filters;
+    const { metadata } = req.object;
+    if (kind !== req.kind.kind) {
+        logger.debug(`${req.kind.kind} does not match ${kind}`);
+        return true;
+    }
+    if (group && group !== req.kind.group) {
+        logger.debug(`${req.kind.group} does not match ${group}`);
+        return true;
+    }
+    if (version && version !== req.kind.version) {
+        logger.debug(`${req.kind.version} does not match ${version}`);
+        return true;
+    }
+    if (namespaces.length && !namespaces.includes(req.namespace || "")) {
+        logger.debug(`${req.namespace} is not in ${namespaces}`);
+        return true;
+    }
+    for (const [key, value] of Object.entries(labels)) {
+        if (metadata?.labels?.[key] !== value) {
+            logger.debug(`${metadata?.labels?.[key]} does not match ${value}`);
+            return true;
+        }
+    }
+    for (const [key, value] of Object.entries(annotations)) {
+        if (metadata?.annotations?.[key] !== value) {
+            logger.debug(`${metadata?.annotations?.[key]} does not match ${value}`);
+            return true;
+        }
+    }
+    return false;
+}
+
+function processor(config, capabilities, req) {
+    const wrapped = new RequestWrapper(req);
+    const response = {
+        uid: req.uid,
+        patchType: "JSONPatch",
+        warnings: [],
+        allowed: false,
+    };
+    logger.info(`Processing '${req.uid}' for '${req.kind.kind}' '${req.name}'`);
+    for (const { name, bindings } of capabilities) {
+        const prefix = `${req.uid} ${req.name}: ${name}`;
+        logger.info(`Processing capability ${name}`, prefix);
+        for (const action of bindings) {
+            if (shouldSkipRequest(action, req)) {
+                continue;
+            }
+            logger.info(`Processing matched action ${action.kind.kind}`, prefix);
+            const { metadata } = wrapped.Raw;
+            const identifier = `pepr.dev/${config.uuid}/${name}`;
+            metadata.annotations = metadata.annotations || {};
+            metadata.annotations[identifier] = "started";
+            try {
+                action.callback(wrapped);
+                metadata.annotations[identifier] = "succeeded";
+            }
+            catch (e) {
+                response.warnings.push(`Action failed: ${e}`);
+                if (config.onError) {
+                    logger.error(`Action failed: ${e}`, prefix);
+                    response.result = "Pepr module configured to reject on error";
+                    return response;
+                }
+                else {
+                    logger.warn(`Action failed: ${e}`, prefix);
+                    metadata.annotations[identifier] = "warning";
+                }
+            }
+        }
+    }
+    response.allowed = true;
+    const patches = fastJsonPatch.compare(req.object, wrapped.Raw);
+    if (patches.length > 0) {
+        response.patch = JSON.stringify(patches);
+    }
+    if (response.warnings.length < 1) {
+        delete response.warnings;
+    }
+    logger.debug(patches);
+    return response;
+}
+
+class PeprModule {
+    get kinds() {
+        return this._kinds;
+    }
+    get UUID() {
+        return this._config.uuid;
+    }
+    constructor({ description, pepr }, additionalCfg) {
+        this._state = [];
+        this._kinds = [];
+        this.Register = (capability) => {
+            logger.info(`Registering capability ${capability.name}`);
+            this._kinds = capability.bindings.map(({ kind }) => kind);
+            this._state.push(capability);
+        };
+        this.ProcessRequest = (req) => {
+            return processor(this._config, this._state, req);
+        };
+        this._config = {
+            alwaysIgnore: {
+                namespaces: ["kube-system", "pepr-system"],
+                labels: [{ "pepr.dev": "ignore" }],
+            },
+            ...pepr,
+            ...additionalCfg,
+            description,
+        };
+    }
+}
+
+var name = "pepr";
+var version = "0.1.4";
+var description = "Kubernetes application engine";
+var author = "Defense Unicorns";
+var homepage = "https://github.com/defenseunicorns/pepr";
+var license = "Apache-2.0";
+var bin = "dist/pepr-cli.js";
+var repository = "defenseunicorns/pepr";
+var engines = {
+	node: ">=18.0.0"
+};
+var pepr = {
+	name: "Development Module",
+	uuid: "20e17cf6-a2e4-46b2-b626-75d88d96c88b",
+	description: "Development module for pepr",
+	version: "dev",
+	onError: "ignore"
+};
+var scripts = {
+	webhook: "node dist/default.js",
+	build: "rollup -c",
+	start: "rollup -c -w --watch.onEnd 'sleep 1 && node dist/pepr-test.js'",
+	test: "ava",
+	lint: "npx eslint src",
+	"lint:fix": "npm run lint -- --fix",
+	prettier: "npx prettier src --check",
+	"prettier:fix": "npm run prettier -- --write",
+	prepublishOnly: "npm run lint:fix && npm run prettier:fix && npm run test && npm run build"
+};
+var dependencies = {
+	"@kubernetes/client-node": "^0.18.1",
+	"@rollup/plugin-json": "^6.0.0",
+	"@rollup/plugin-node-resolve": "^15.0.1",
+	"@rollup/plugin-typescript": "^11.0.0",
+	"@types/ramda": "^0.28.23",
+	chokidar: "^3.5.3",
+	commander: "^10.0.0",
+	express: "^4.18.2",
+	"fast-json-patch": "^3.1.1",
+	prompts: "^2.4.2",
+	ramda: "^0.28.0",
+	rollup: "^3.20.2",
+	uuid: "^9.0.0",
+	tslib: "^2.5.0",
+	typescript: "^5.0.2"
+};
+var devDependencies = {
+	"@types/prompts": "^2.4.4",
+	"@types/uuid": "^9.0.1",
+	"@typescript-eslint/eslint-plugin": "^5.57.0",
+	"@typescript-eslint/parser": "^5.57.0",
+	ava: "^5.2.0",
+	eslint: "^8.37.0",
+	prettier: "^2.8.7",
+	"rollup-plugin-visualizer": "^5.9.0",
+	"ts-node": "^10.9.1",
+	"tsconfig-paths": "^4.1.2"
+};
+var ava = {
+	extensions: [
+		"ts"
+	],
+	require: [
+		"ts-node/register",
+		"tsconfig-paths/register"
+	]
+};
+var cfg = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	homepage: homepage,
+	license: license,
+	bin: bin,
+	repository: repository,
+	engines: engines,
+	pepr: pepr,
+	scripts: scripts,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	ava: ava
+};
+
+const { Register, ProcessRequest } = new PeprModule(cfg, {
+    alwaysIgnore: {
+        namespaces: [],
+        labels: [],
+    },
+});
+
+exports.ProcessRequest = ProcessRequest;
+exports.Register = Register;