@empire-builder-kit/containers 0.0.1-alpha.4

package/dist/generators/task/files-typescript/src/main.ts.template

@@ -0,0 +1,45 @@
+import { formatLogEvent, readTaskConfig, runTask, type TaskInput } from './task.js';
+
+function readTaskInput(env: NodeJS.ProcessEnv = process.env): TaskInput {
+  const trigger = env.TASK_TRIGGER?.trim();
+
+  return {
+    trigger: trigger && trigger.length > 0 ? trigger : 'manual',
+  };
+}
+
+async function main() {
+  const config = readTaskConfig();
+  const input = readTaskInput();
+
+  console.log(
+    formatLogEvent(config, 'task.started', {
+      trigger: input.trigger,
+    })
+  );
+
+  const result = await runTask(config, input);
+
+  console.log(
+    formatLogEvent(config, 'task.completed', {
+      status: result.status,
+      trigger: result.trigger,
+    })
+  );
+
+  console.log(JSON.stringify(result));
+}
+
+void main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : 'Unknown task failure';
+
+  console.error(
+    JSON.stringify({
+      level: 'error',
+      message: 'task.failed',
+      error: message,
+    })
+  );
+
+  process.exitCode = 1;
+});

package/dist/generators/task/files-typescript/src/task.spec.ts.template

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { createTaskResult, formatLogEvent, readTaskConfig, runTask } from './task.js';
+
+describe('task helpers', () => {
+  it('falls back to task defaults', () => {
+    expect(readTaskConfig({})).toEqual({
+      taskName: '<%= className %>Task',
+      version: '0.0.1',
+    });
+  });
+
+  it('builds a stable task result', () => {
+    expect(
+      createTaskResult(
+        {
+          taskName: '<%= className %>Task',
+          version: '1.2.3',
+        },
+        { trigger: 'schedule' }
+      )
+    ).toEqual({
+      status: 'ok',
+      task: '<%= className %>Task',
+      trigger: 'schedule',
+      version: '1.2.3',
+    });
+  });
+
+  it('formats structured log output', () => {
+    expect(
+      formatLogEvent(
+        {
+          taskName: '<%= className %>Task',
+          version: '1.2.3',
+        },
+        'task.started',
+        { trigger: 'manual' }
+      )
+    ).toBe(
+      JSON.stringify({
+        level: 'info',
+        message: 'task.started',
+        task: '<%= className %>Task',
+        version: '1.2.3',
+        trigger: 'manual',
+      })
+    );
+  });
+
+  it('runs the starter task', async () => {
+    await expect(
+      runTask(
+        {
+          taskName: '<%= className %>Task',
+          version: '1.2.3',
+        },
+        { trigger: 'queue' }
+      )
+    ).resolves.toEqual({
+      status: 'ok',
+      task: '<%= className %>Task',
+      trigger: 'queue',
+      version: '1.2.3',
+    });
+  });
+});

package/dist/generators/task/files-typescript/src/task.ts.template

@@ -0,0 +1,71 @@
+export interface TaskConfig {
+  taskName: string;
+  version: string;
+}
+
+export interface TaskInput {
+  trigger: string;
+}
+
+export interface TaskResult {
+  status: 'ok';
+  task: string;
+  trigger: string;
+  version: string;
+}
+
+export interface LogContext {
+  [key: string]: string | number | boolean | null;
+}
+
+const DEFAULT_TASK_NAME = '<%= className %>Task';
+const DEFAULT_TASK_VERSION = '0.0.1';
+
+function readOptionalEnv(
+  env: NodeJS.ProcessEnv,
+  key: string,
+  fallback: string
+): string {
+  const value = env[key]?.trim();
+  return value && value.length > 0 ? value : fallback;
+}
+
+export function readTaskConfig(env: NodeJS.ProcessEnv = process.env): TaskConfig {
+  return {
+    taskName: readOptionalEnv(env, 'TASK_NAME', DEFAULT_TASK_NAME),
+    version: readOptionalEnv(env, 'TASK_VERSION', DEFAULT_TASK_VERSION),
+  };
+}
+
+export function createTaskResult(
+  config: TaskConfig,
+  input: TaskInput
+): TaskResult {
+  return {
+    status: 'ok',
+    task: config.taskName,
+    trigger: input.trigger,
+    version: config.version,
+  };
+}
+
+export async function runTask(
+  config: TaskConfig,
+  input: TaskInput
+): Promise<TaskResult> {
+  return createTaskResult(config, input);
+}
+
+export function formatLogEvent(
+  config: TaskConfig,
+  message: string,
+  context: LogContext = {}
+): string {
+  return JSON.stringify({
+    level: 'info',
+    message,
+    task: config.taskName,
+    version: config.version,
+    ...context,
+  });
+}

package/dist/generators/task/files-typescript/tsconfig.app.json.template

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./dist/tsconfig.app.tsbuildinfo"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.spec.ts"]
+}

package/dist/generators/task/files-typescript/tsconfig.json.template

@@ -0,0 +1,19 @@
+{
+  "extends": "<%= offsetFromRoot %>tsconfig.base.json",
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "ES2022",
+    "types": ["node", "vitest/globals"]
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/dist/generators/task/files-typescript/tsconfig.spec.json.template

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "noEmit": true,
+    "tsBuildInfoFile": "./dist/tsconfig.spec.tsbuildinfo"
+  },
+  "include": ["src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/dist/generators/task/files-typescript/vitest.config.mts.template

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+    include: ['src/**/*.spec.ts'],
+  },
+});

package/dist/generators/task/schema.d.ts

@@ -0,0 +1,8 @@
+export interface TaskGeneratorSchema {
+  name: string;
+  app: string;
+  language?: 'typescript' | 'rust' | 'go' | 'python';
+  directory?: string;
+  skipFormat?: boolean;
+  tags?: string;
+}

package/dist/generators/task/schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "Task",
+  "title": "Generate an EBK container task",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Name for the task within the app group.",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "What name should the task have?"
+    },
+    "app": {
+      "type": "string",
+      "description": "Owning Empire Builder Kit app-group name.",
+      "x-prompt": "Which app group should receive the task?"
+    },
+    "language": {
+      "type": "string",
+      "description": "Programming language for the task.",
+      "enum": ["typescript", "rust", "go", "python"],
+      "default": "typescript"
+    },
+    "directory": {
+      "type": "string",
+      "description": "Base directory for app groups.",
+      "default": "packages"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Comma-separated additional tags to apply to the project."
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files.",
+      "default": false
+    }
+  },
+  "required": ["name", "app"]
+}

package/dist/generators/task/task.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+import { TaskGeneratorSchema } from './schema';
+export declare function taskGenerator(tree: Tree, options: TaskGeneratorSchema): Promise<void>;
+export default taskGenerator;
+//# sourceMappingURL=task.d.ts.map

package/dist/generators/task/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../src/generators/task/task.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,IAAI,EACL,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AA+M/C,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,mBAAmB,iBA6C3E;AAED,eAAe,aAAa,CAAC"}

package/dist/generators/task/task.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskGenerator = taskGenerator;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const path = tslib_1.__importStar(require("node:path"));
+function runtimeForLanguage(language) {
+    switch (language) {
+        case 'typescript':
+            return 'node';
+        case 'rust':
+            return 'native';
+        case 'go':
+            return 'native';
+        case 'python':
+            return 'python';
+    }
+}
+function targetsForLanguage(language, projectRoot, projectName, outputPath) {
+    const cwd = projectRoot;
+    switch (language) {
+        case 'typescript':
+            return {
+                build: {
+                    executor: 'nx:run-commands',
+                    outputs: [`{workspaceRoot}/${outputPath}`],
+                    options: { cwd, command: 'tsc -p tsconfig.app.json' },
+                },
+                lint: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'eslint .' },
+                },
+                typecheck: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'tsc --noEmit -p tsconfig.json' },
+                },
+                test: {
+                    executor: 'nx:run-commands',
+                    options: {
+                        cwd,
+                        command: 'vitest run --config vitest.config.mts',
+                    },
+                },
+                dev: {
+                    executor: 'nx:run-commands',
+                    options: {
+                        cwd,
+                        command: 'node --watch --enable-source-maps --import @swc-node/register/esm-register src/main.ts',
+                    },
+                },
+                'docker-build': {
+                    executor: 'nx:run-commands',
+                    options: {
+                        command: `docker build --tag ${projectName} ${projectRoot}`,
+                    },
+                },
+            };
+        case 'rust':
+            return {
+                build: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'cargo build --release' },
+                },
+                lint: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'cargo clippy -- -D warnings' },
+                },
+                test: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'cargo test' },
+                },
+                dev: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'cargo run' },
+                },
+                'docker-build': {
+                    executor: 'nx:run-commands',
+                    options: {
+                        command: `docker build --tag ${projectName} ${projectRoot}`,
+                    },
+                },
+            };
+        case 'go':
+            return {
+                build: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'go build -o bin/task ./cmd/...' },
+                },
+                lint: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'golangci-lint run' },
+                },
+                typecheck: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'go vet ./...' },
+                },
+                test: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'go test ./...' },
+                },
+                dev: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'go run ./cmd/...' },
+                },
+                'docker-build': {
+                    executor: 'nx:run-commands',
+                    options: {
+                        command: `docker build --tag ${projectName} ${projectRoot}`,
+                    },
+                },
+            };
+        case 'python':
+            return {
+                lint: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'ruff check .' },
+                },
+                typecheck: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'mypy src/' },
+                },
+                test: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'pytest' },
+                },
+                dev: {
+                    executor: 'nx:run-commands',
+                    options: { cwd, command: 'python src/main.py' },
+                },
+                'docker-build': {
+                    executor: 'nx:run-commands',
+                    options: {
+                        command: `docker build --tag ${projectName} ${projectRoot}`,
+                    },
+                },
+            };
+    }
+}
+function normalizeOptions(options) {
+    const appNames = (0, devkit_1.names)(options.app);
+    const taskNames = (0, devkit_1.names)(options.name);
+    const language = options.language ?? 'typescript';
+    const directory = (options.directory ?? 'packages').replace(/\\/g, '/');
+    const projectRoot = (0, devkit_1.joinPathFragments)(directory, appNames.fileName, 'apps', 'task', taskNames.fileName);
+    const userTags = options.tags
+        ?.split(',')
+        .map((tag) => tag.trim())
+        .filter(Boolean) ?? [];
+    return {
+        app: appNames.fileName,
+        appName: appNames.fileName,
+        className: appNames.className,
+        directory,
+        language,
+        name: taskNames.fileName,
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(projectRoot),
+        outputPath: (0, devkit_1.joinPathFragments)('dist', projectRoot),
+        projectName: `${appNames.fileName}-task-${taskNames.fileName}`,
+        projectRoot,
+        projectTitle: `${appNames.className} Task ${taskNames.className}`,
+        skipFormat: options.skipFormat,
+        tags: [
+            `scope:${appNames.fileName}`,
+            'layer:app',
+            'type:task',
+            `runtime:${runtimeForLanguage(language)}`,
+            'deploy:container',
+            'visibility:internal',
+            ...userTags,
+        ],
+    };
+}
+async function taskGenerator(tree, options) {
+    const normalized = normalizeOptions(options);
+    const appRoot = (0, devkit_1.joinPathFragments)(normalized.directory, normalized.appName);
+    if (!tree.exists(appRoot)) {
+        throw new Error(`App group "${normalized.app}" does not exist at "${appRoot}". Generate the app group first.`);
+    }
+    if (tree.exists((0, devkit_1.joinPathFragments)(normalized.projectRoot, 'project.json')) ||
+        tree.exists((0, devkit_1.joinPathFragments)(normalized.projectRoot, 'package.json'))) {
+        throw new Error(`Task "${normalized.name}" already exists at "${normalized.projectRoot}".`);
+    }
+    (0, devkit_1.addProjectConfiguration)(tree, normalized.projectName, {
+        root: normalized.projectRoot,
+        projectType: 'application',
+        sourceRoot: `${normalized.projectRoot}/src`,
+        tags: normalized.tags,
+        targets: targetsForLanguage(normalized.language, normalized.projectRoot, normalized.projectName, normalized.outputPath),
+    });
+    (0, devkit_1.generateFiles)(tree, path.join(__dirname, `files-${normalized.language}`), normalized.projectRoot, {
+        ...normalized,
+        tmpl: '',
+    });
+    if (!normalized.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = taskGenerator;

package/dist/generators.json

@@ -0,0 +1,14 @@
+{
+  "generators": {
+    "service": {
+      "factory": "./dist/generators/service/service",
+      "schema": "./dist/generators/service/schema.json",
+      "description": "Generate service artifacts for @empire-builder-kit/containers."
+    },
+    "task": {
+      "factory": "./dist/generators/task/task",
+      "schema": "./dist/generators/task/schema.json",
+      "description": "Generate task artifacts for @empire-builder-kit/containers."
+    }
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { serviceGenerator } from './generators/service/service.js';
+export { taskGenerator } from './generators/task/task.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskGenerator = exports.serviceGenerator = void 0;
+var service_js_1 = require("./generators/service/service.js");
+Object.defineProperty(exports, "serviceGenerator", { enumerable: true, get: function () { return service_js_1.serviceGenerator; } });
+var task_js_1 = require("./generators/task/task.js");
+Object.defineProperty(exports, "taskGenerator", { enumerable: true, get: function () { return task_js_1.taskGenerator; } });

package/executors.json

@@ -0,0 +1,3 @@
+{
+  "executors": {}
+}

package/generators.json

@@ -0,0 +1,14 @@
+{
+  "generators": {
+    "service": {
+      "factory": "./dist/generators/service/service",
+      "schema": "./dist/generators/service/schema.json",
+      "description": "Generate service artifacts for @empire-builder-kit/containers."
+    },
+    "task": {
+      "factory": "./dist/generators/task/task",
+      "schema": "./dist/generators/task/schema.json",
+      "description": "Generate task artifacts for @empire-builder-kit/containers."
+    }
+  }
+}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@empire-builder-kit/containers",
+  "version": "0.0.1-alpha.4",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@org/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "nx": {
+    "name": "@empire-builder-kit/containers",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:tsc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/containers/dist",
+          "main": "packages/containers/src/index.ts",
+          "tsConfig": "packages/containers/tsconfig.lib.json",
+          "rootDir": "packages/containers/src",
+          "generatePackageJson": false,
+          "assets": [
+            {
+              "input": "./packages/containers/src",
+              "glob": "**/!(*.ts)",
+              "output": "."
+            },
+            {
+              "input": "./packages/containers/src",
+              "glob": "**/.*",
+              "output": "."
+            },
+            {
+              "input": "./packages/containers/src",
+              "glob": "**/*.d.ts",
+              "output": "."
+            },
+            {
+              "input": "./packages/containers",
+              "glob": "generators.json",
+              "output": "."
+            },
+            {
+              "input": "./packages/containers",
+              "glob": "executors.json",
+              "output": "."
+            }
+          ]
+        }
+      }
+    },
+    "tags": [
+      "scope:workspace",
+      "layer:tooling",
+      "visibility:public"
+    ]
+  },
+  "dependencies": {
+    "@nx/devkit": "22.6.5",
+    "tslib": "^2.3.0",
+    "vitest": "4.1.4"
+  },
+  "generators": "./generators.json",
+  "executors": "./executors.json",
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "generators.json",
+    "executors.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LukasGuptaLeary/empire-builder-kit.git",
+    "directory": "packages/containers"
+  },
+  "bugs": {
+    "url": "https://github.com/LukasGuptaLeary/empire-builder-kit/issues"
+  },
+  "homepage": "https://github.com/LukasGuptaLeary/empire-builder-kit#readme"
+}