k8ts
Version:
Powerful framework for building Kubernetes manifests in TypeScript.
129 lines • 4.3 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Assembler = void 0;
const doddle_1 = require("doddle");
const emittery_1 = __importDefault(require("emittery"));
const lodash_1 = require("lodash");
const loader_1 = require("./loader");
const manifester_1 = require("./manifester");
const saver_1 = require("./saver");
const serializer_1 = require("./serializer");
const validator_1 = require("./validator");
class Assembler extends emittery_1.default {
_options;
constructor(_options) {
super();
this._options = _options;
}
async assemble(inFiles) {
const _emit = async (event, payload) => {
return await this.emit(event, payload);
};
const validator = new validator_1.NodeGraphValidator({});
const loader = new loader_1.ResourceLoader({});
loader.onAny(_emit);
const generator = new manifester_1.Manifester({
cwd: this._options.cwd
});
generator.onAny(_emit);
const serializer = new serializer_1.YamlSerializer({});
serializer.onAny(_emit);
const saver = new saver_1.ManifestSaver({
outdir: this._options.outdir
});
saver.onAny(_emit);
const reports = (0, doddle_1.aseq)(inFiles)
.before(async () => {
await _emit("stage", { stage: "gathering" });
})
.each(async (file) => {
await _emit("received-file", { file: file.__node__ });
})
.after(async () => {
await _emit("stage", { stage: "loading" });
})
.collect()
.map(async (file) => {
const loaded = await loader.load(file);
loaded.forEach(r => r.meta.add(this._options.meta));
return {
file: file.__entity__,
resources: loaded.filter(x => !x.isExternal)
};
})
.after(async () => {
await _emit("stage", { stage: "manifesting" });
})
.collect()
.map(async ({ file, resources }) => {
const manifests = await (0, doddle_1.aseq)(resources)
.map(async (resource) => {
return await generator.generate(resource);
})
.toArray()
.pull();
return {
file: file.node,
resources: manifests
};
})
.after(async () => {
await _emit("stage", { stage: "validating" });
})
.chunk(1000000)
.concatMap(async (x) => {
validator.validate(x);
return x;
})
.after(async () => {
await _emit("stage", { stage: "serializing" });
})
.map(async ({ file, resources }) => {
const artifacts = await (0, doddle_1.aseq)(resources)
.map(async (obj) => {
return {
...obj,
yaml: await serializer.serialize(obj.manifest)
};
})
.toArray()
.pull();
return {
file,
artifacts
};
})
.after(async () => {
await _emit("stage", { stage: "saving" });
})
.after(async () => {
await saver.prepareOnce();
})
.collect()
.map(async ({ file, artifacts }) => {
const { filename, bytes, path } = await saver.save(file, artifacts.map(x => x.yaml));
return {
file: file,
path,
filename,
bytes,
artifacts
};
})
.after(async () => {
await _emit("stage", { stage: "done" });
})
.collect()
.toArray();
const files = (await reports.pull());
return {
files,
options: (0, lodash_1.cloneDeep)(this._options)
};
}
}
exports.Assembler = Assembler;
//# sourceMappingURL=assembler.js.map