@get-enlace/nest 0.0.1

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+/** DI token for injecting a module instance's {@link EnlaceOptions} into its controller. */
+export declare const ENLACE_OPTIONS: unique symbol;

package/dist/constants.js

@@ -0,0 +1,2 @@
+/** DI token for injecting a module instance's {@link EnlaceOptions} into its controller. */
+export const ENLACE_OPTIONS = Symbol('ENLACE_OPTIONS');

package/dist/enlace.controller.d.ts

@@ -0,0 +1,15 @@
+import type { EnlaceOptions } from './enlace.module.js';
+/**
+ * Serves the raw OpenAPI document at `<mount>/api/spec`. Read fresh on each
+ * request, not cached — matches the "not stored, read fresh each load" rule
+ * from ARCHITECTURE.md §4, same as the express adapter's `/api/spec` route.
+ *
+ * This is the only route this adapter defines — per ARCHITECTURE.md's MVP
+ * model, execution runs entirely client-side in @get-enlace/ui, so there's
+ * no `/api/run` or `/api/credentials` here at all.
+ */
+export declare class EnlaceController {
+    private readonly options;
+    constructor(options: EnlaceOptions);
+    getSpec(): Record<string, any>;
+}

package/dist/enlace.controller.js

@@ -0,0 +1,44 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Inject } from '@nestjs/common';
+import { ENLACE_OPTIONS } from './constants.js';
+import { loadSpec } from './specLoader.js';
+/**
+ * Serves the raw OpenAPI document at `<mount>/api/spec`. Read fresh on each
+ * request, not cached — matches the "not stored, read fresh each load" rule
+ * from ARCHITECTURE.md §4, same as the express adapter's `/api/spec` route.
+ *
+ * This is the only route this adapter defines — per ARCHITECTURE.md's MVP
+ * model, execution runs entirely client-side in @get-enlace/ui, so there's
+ * no `/api/run` or `/api/credentials` here at all.
+ */
+let EnlaceController = class EnlaceController {
+    constructor(options) {
+        this.options = options;
+    }
+    getSpec() {
+        return loadSpec(this.options.spec);
+    }
+};
+__decorate([
+    Get('spec'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], EnlaceController.prototype, "getSpec", null);
+EnlaceController = __decorate([
+    Controller('api'),
+    __param(0, Inject(ENLACE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], EnlaceController);
+export { EnlaceController };

package/dist/enlace.module.d.ts

@@ -0,0 +1,36 @@
+import { DynamicModule } from '@nestjs/common';
+import type { SpecSource } from './specLoader.js';
+export interface EnlaceOptions {
+    /** A file/URL path or an already-parsed object — the only input this needs is a valid OpenAPI 3.x document, however it's produced or served. */
+    spec: SpecSource;
+    /**
+     * Mount path for the canvas, e.g. `'enlace'` serves the UI at `/enlace`
+     * and the spec at `/enlace/api/spec`. Defaults to `'enlace'`.
+     *
+     * Nest controller prefixes are fixed at decorator time, so this can't
+     * vary per `forRoot()` call the way the express adapter's `app.use(path,
+     * enlace(...))` does — it's applied via `RouterModule.register()` instead,
+     * the standard Nest pattern for a dynamic module with a configurable
+     * route prefix.
+     */
+    path?: string;
+}
+/**
+ * Mounts the Enlace canvas.
+ *
+ *   @Module({ imports: [EnlaceModule.forRoot({ spec })] })
+ *   export class AppModule {}
+ *
+ * This adapter's job is deliberately small — per ARCHITECTURE.md's MVP
+ * model, execution runs entirely client-side in @get-enlace/ui, so there's
+ * no `/api/run` or `/api/credentials` here at all. All this does is:
+ *   - serve the raw OpenAPI document (parsed into an Operation[] list
+ *     client-side, not here — see @get-enlace/ui's engine/specParser.ts),
+ *     via EnlaceController
+ *   - serve the built UI bundle, via @nestjs/serve-static (platform-
+ *     agnostic — works whether the host app runs Nest's Express or Fastify
+ *     adapter, unlike @get-enlace/express's direct `express.static` use)
+ */
+export declare class EnlaceModule {
+    static forRoot(options: EnlaceOptions): DynamicModule;
+}

package/dist/enlace.module.js

@@ -0,0 +1,70 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var EnlaceModule_1;
+import { Module } from '@nestjs/common';
+import { RouterModule } from '@nestjs/core';
+import { ServeStaticModule } from '@nestjs/serve-static';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { ENLACE_OPTIONS } from './constants.js';
+import { EnlaceController } from './enlace.controller.js';
+const require = createRequire(import.meta.url);
+/**
+ * Mounts the Enlace canvas.
+ *
+ *   @Module({ imports: [EnlaceModule.forRoot({ spec })] })
+ *   export class AppModule {}
+ *
+ * This adapter's job is deliberately small — per ARCHITECTURE.md's MVP
+ * model, execution runs entirely client-side in @get-enlace/ui, so there's
+ * no `/api/run` or `/api/credentials` here at all. All this does is:
+ *   - serve the raw OpenAPI document (parsed into an Operation[] list
+ *     client-side, not here — see @get-enlace/ui's engine/specParser.ts),
+ *     via EnlaceController
+ *   - serve the built UI bundle, via @nestjs/serve-static (platform-
+ *     agnostic — works whether the host app runs Nest's Express or Fastify
+ *     adapter, unlike @get-enlace/express's direct `express.static` use)
+ */
+let EnlaceModule = EnlaceModule_1 = class EnlaceModule {
+    static forRoot(options) {
+        const mountPath = options.path ?? 'enlace';
+        // Resolved via Node's own module resolution against the installed
+        // `@get-enlace/ui` package (a real dependency, see package.json) — not a
+        // relative path into this monorepo — so this works identically whether
+        // `@get-enlace/ui` got here via an npm workspace symlink (local dev) or
+        // a real `node_modules` install (anyone who installs @get-enlace/nest on
+        // its own). There's nothing to copy or build into this package itself;
+        // the bundle lives wherever @get-enlace/ui's own "files" field ships it
+        // (dist/), and it must already be built (`npm run build --workspace
+        // @get-enlace/ui`) before this resolves.
+        const uiPackageJson = require.resolve('@get-enlace/ui/package.json');
+        const uiDist = path.join(path.dirname(uiPackageJson), 'dist');
+        return {
+            module: EnlaceModule_1,
+            imports: [
+                ServeStaticModule.forRoot({
+                    rootPath: uiDist,
+                    serveRoot: `/${mountPath}`,
+                    // Keeps the static middleware from shadowing EnlaceController's
+                    // `/api/spec` route. `{*splat}` is path-to-regexp v8's wildcard
+                    // syntax (the version @nestjs/serve-static v5 bundles) — the
+                    // older unnamed `(.*)` capture group it replaces silently 500s
+                    // instead of matching, since it's now invalid syntax rather than
+                    // just non-matching.
+                    exclude: [`/${mountPath}/api/{*splat}`],
+                }),
+                RouterModule.register([{ path: mountPath, module: EnlaceModule_1 }]),
+            ],
+            controllers: [EnlaceController],
+            providers: [{ provide: ENLACE_OPTIONS, useValue: options }],
+        };
+    }
+};
+EnlaceModule = EnlaceModule_1 = __decorate([
+    Module({})
+], EnlaceModule);
+export { EnlaceModule };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { EnlaceModule } from './enlace.module.js';
+export type { EnlaceOptions } from './enlace.module.js';
+export type { SpecSource } from './specLoader.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { EnlaceModule } from './enlace.module.js';

package/dist/specLoader.d.ts

@@ -0,0 +1,6 @@
+export type SpecSource = string | Record<string, any>;
+/**
+ * Reads an OpenAPI 3.x document from a file/URL path or accepts an already-
+ * parsed object directly.
+ */
+export declare function loadSpec(source: SpecSource): Record<string, any>;

package/dist/specLoader.js

@@ -0,0 +1,17 @@
+import { readFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import yaml from 'js-yaml';
+/**
+ * Reads an OpenAPI 3.x document from a file/URL path or accepts an already-
+ * parsed object directly.
+ */
+export function loadSpec(source) {
+    if (typeof source !== 'string')
+        return source;
+    const raw = readFileSync(source, 'utf-8');
+    const ext = extname(source);
+    if (ext === '.yaml' || ext === '.yml') {
+        return yaml.load(raw);
+    }
+    return JSON.parse(raw);
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@get-enlace/nest",
+  "private": false,
+  "version": "0.0.1",
+  "description": "Simple NestJS adapter for @get-enlace/ui. Early dev preview: no persistence yet (serves the spec + UI bundle only), install via the `dev` dist-tag on GitHub Packages.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/get-enlace/enlace-js.git",
+    "directory": "packages/enlace-nest"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/serve-static": "^4.0.0 || ^5.0.0",
+    "reflect-metadata": "^0.1.13 || ^0.2.0"
+  },
+  "dependencies": {
+    "@get-enlace/ui": "0.0.1",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.2.1",
+    "@nestjs/core": "^11.2.1",
+    "@nestjs/platform-express": "^11.2.1",
+    "@nestjs/serve-static": "^5.0.5",
+    "@nestjs/testing": "^11.2.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.19.43",
+    "@types/supertest": "^7.2.1",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2",
+    "supertest": "^7.2.2",
+    "typescript": "^5.5.4",
+    "vitest": "^4.1.11"
+  }
+}