@intentius/chant-lexicon-docker 0.124.45 → 0.124.48

package/src/import/embedded-live.test.ts

@@ -0,0 +1,248 @@
+/**
+ * A `DockerOtelCollector`'s config through `chant import` (#3373, #4388): the
+ * config's `content` is handed to the otel importer, and a live import
+ * (`chant import --from`, against a fake Engine API) gives the same otel
+ * source a file import of the build's `docker-compose.yml` gives, and both
+ * give what `chant import config.yaml` gives for the config itself.
+ */
+
+import { describe, expect, test } from "vitest";
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { join, relative, resolve } from "path";
+import { load } from "js-yaml";
+import { importCommand, liveImportFromPlugins } from "@intentius/chant/cli/commands/import";
+import type { LexiconPlugin } from "@intentius/chant/lexicon";
+import { build } from "@intentius/chant/build";
+import { EmbeddedImports } from "@intentius/chant/import/embedded";
+import { COLLECTOR_CONFIG_PATH, otelPlugin, otelSerializer } from "@intentius/chant-lexicon-otel";
+import { OtelCollectorParser } from "@intentius/chant-lexicon-otel/import/parser";
+import { OtelCollectorGenerator } from "@intentius/chant-lexicon-otel/import/generator";
+import { dockerPlugin } from "../plugin";
+import { dockerSerializer } from "../serializer";
+import { exportResources } from "../export-resources";
+import type { DockerEngine } from "./engine";
+import { DockerParser } from "./parser";
+import { tarOf } from "./testdata/tar";
+
+type Json = Record<string, unknown>;
+
+const pkgDir = resolve(import.meta.dirname, "../..");
+
+const SOURCE = `import { DockerOtelCollector } from "@intentius/chant-lexicon-docker";
+import { OtlpHttpExporter } from "@intentius/chant-lexicon-otel";
+
+export const otel = DockerOtelCollector({
+  exporters: [new OtlpHttpExporter({ endpoint: "https://otlp.example.com" })],
+});
+`;
+
+function walk(dir: string, root: string, out: Record<string, string>): void {
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry);
+    if (statSync(path).isDirectory()) walk(path, root, out);
+    else out[relative(root, path)] = readFileSync(path, "utf-8");
+  }
+}
+
+function project(): { dir: string; srcDir: string } {
+  const dir = mkdtempSync(join(pkgDir, ".roundtrip-tmp-"));
+  writeFileSync(join(dir, "package.json"), '{ "name": "docker-embedded", "private": true, "type": "module" }\n');
+  writeFileSync(join(dir, "chant.config.ts"), 'export default { lexicons: ["docker", "otel"] };\n');
+  const srcDir = join(dir, "src");
+  mkdirSync(srcDir);
+  return { dir, srcDir };
+}
+
+function files(srcDir: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  walk(srcDir, srcDir, out);
+  return out;
+}
+
+function composeOf(out: unknown): string {
+  if (typeof out === "string") return out;
+  const o = out as { primary?: string; files?: Record<string, string> };
+  if (typeof o.primary === "string") return o.primary;
+  const yml = Object.entries(o.files ?? {}).find(([p]) => /compose/.test(p));
+  if (!yml) throw new Error("no compose file in the build");
+  return yml[1];
+}
+
+/** The build's compose document for `source`. */
+async function compose(source: string): Promise<{ text: string; doc: Json }> {
+  const { dir, srcDir } = project();
+  try {
+    writeFileSync(join(srcDir, "main.ts"), source);
+    const result = await build(srcDir, [dockerSerializer, otelSerializer]);
+    expect(result.errors).toEqual([]);
+    const text = composeOf(result.outputs.get("docker"));
+    return { text, doc: load(text) as Json };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/** The collector's service key and its config text. */
+function collector(doc: Json): { service: string; config: string } {
+  const services = doc.services as Record<string, Json>;
+  const [service, svc] = Object.entries(services).find(([, s]) => Array.isArray(s.configs))!;
+  const source = (svc.configs as Json[])[0]!.source as string;
+  return { service, config: (doc.configs as Record<string, Json>)[source]!.content as string };
+}
+
+/** `chant import config.yaml`: the otel modules for the config alone. */
+function standalone(text: string): Record<string, string> {
+  return Object.fromEntries(new OtelCollectorGenerator().generate(new OtelCollectorParser().parse(text)).map((f) => [f.path, f.content]));
+}
+
+/** The modules under `dir/`, keyed by their path inside it. */
+function under(all: Record<string, string>, dir: string): Record<string, string> {
+  return Object.fromEntries(Object.entries(all).filter(([p]) => p.startsWith(`${dir}/`)).map(([p, c]) => [p.slice(dir.length + 1), c]));
+}
+
+/**
+ * A fake Engine holding the collector's container as compose creates it: the
+ * service's command, ports and restart policy, compose's labels, and the
+ * config's content in the container at its target.
+ */
+function engine(project: string, service: string, svc: Json, configText: string): DockerEngine {
+  const target = ((svc.configs as Json[])[0]!.target as string) ?? COLLECTOR_CONFIG_PATH;
+  const portBindings: Record<string, Array<{ HostIp: string; HostPort: string }>> = {};
+  for (const p of (svc.ports as string[]) ?? []) {
+    const [host, rest] = p.split(":");
+    const [port, proto] = rest!.split("/");
+    portBindings[`${port}/${proto ?? "tcp"}`] = [{ HostIp: "", HostPort: host! }];
+  }
+  const labels = {
+    "com.docker.compose.project": project,
+    "com.docker.compose.service": service,
+    "com.docker.compose.container-number": "1",
+    "com.docker.compose.oneoff": "False",
+    "com.docker.compose.config-hash": "abc",
+  };
+  const inspect = {
+    Id: "c1",
+    Name: `/${project}-${service}-1`,
+    Config: {
+      Image: svc.image,
+      Cmd: svc.command,
+      Entrypoint: ["/otelcol-contrib"],
+      Env: ["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],
+      Labels: { ...labels, "org.opencontainers.image.title": "otelcol-contrib" },
+      WorkingDir: "",
+      User: "10001",
+    },
+    HostConfig: { PortBindings: portBindings, RestartPolicy: { Name: svc.restart, MaximumRetryCount: 0 } },
+    Mounts: [],
+    NetworkSettings: { Networks: { [`${project}_default`]: {} } },
+  };
+  const image = {
+    Config: {
+      Cmd: ["--config", "/etc/otelcol-contrib/config.yaml"],
+      Entrypoint: ["/otelcol-contrib"],
+      Env: ["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"],
+      Labels: { "org.opencontainers.image.title": "otelcol-contrib" },
+      User: "10001",
+    },
+  };
+  const ok = (body: unknown) => ({ status: 200, body: Buffer.from(JSON.stringify(body)) });
+  return async (path) => {
+    const url = new URL(`http://docker${path}`);
+    if (url.pathname === "/containers/json") {
+      const filters = JSON.parse(url.searchParams.get("filters") ?? "{}") as { label?: string[] };
+      expect(filters.label).toEqual([`com.docker.compose.project=${project}`]);
+      return ok([{ Id: "c1", Labels: labels }]);
+    }
+    if (url.pathname === "/containers/c1/json") return ok(inspect);
+    if (url.pathname.startsWith("/images/")) return ok(image);
+    if (url.pathname === "/containers/c1/archive") {
+      if (url.searchParams.get("path") !== target) return { status: 404, body: Buffer.from('{"message":"not found"}') };
+      return { status: 200, body: tarOf([target.split("/").pop()!, configText]) };
+    }
+    return { status: 404, body: Buffer.alloc(0) };
+  };
+}
+
+describe("DockerOtelCollector through chant import (#3373, #4388)", () => {
+  test("a live import gives the otel source a file import gives, and builds back to the same config", async () => {
+    const { text: composeText, doc } = await compose(SOURCE);
+    const { service, config } = collector(doc);
+    const expected = standalone(config);
+    expect(Object.keys(expected).length).toBeGreaterThan(0);
+
+    const fileProject = project();
+    const liveProject = project();
+    try {
+      // File import of the build's docker-compose.yml.
+      const templatePath = join(fileProject.dir, "docker-compose.yml");
+      writeFileSync(templatePath, composeText);
+      const fileResult = await importCommand({ templatePath, output: fileProject.srcDir, lexicon: "docker" });
+      expect(fileResult.error).toBeUndefined();
+      expect(fileResult.warnings.filter((w) => w.includes("kept as written"))).toEqual([]);
+      const fromFile = files(fileProject.srcDir);
+
+      // Live import from a fake Engine.
+      const svc = (doc.services as Record<string, Json>)[service]!;
+      const plugin: LexiconPlugin = { ...dockerPlugin, exportResources: (options) => exportResources(options, engine("test", service, svc, config)) };
+      const liveResult = await liveImportFromPlugins([plugin, otelPlugin], {
+        environment: "test",
+        output: liveProject.srcDir,
+        lexicon: "docker",
+        force: true,
+      });
+      expect(liveResult.error).toBeUndefined();
+      expect(liveResult.success).toBe(true);
+      expect(liveResult.warnings.filter((w) => w.includes("kept as written"))).toEqual([]);
+      const fromLive = files(liveProject.srcDir);
+
+      const dir = service.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      expect(under(fromLive, dir)).toEqual(expected);
+      expect(under(fromFile, dir)).toEqual(expected);
+      expect(fromLive["main.ts"]).toContain('import { collectorYaml } from "@intentius/chant-lexicon-otel";');
+      expect(fromLive["main.ts"]).toContain("content: collectorYaml(");
+
+      // The imported source builds back to the same service and config.
+      const result = await build(liveProject.srcDir, [dockerSerializer, otelSerializer]);
+      expect(result.errors).toEqual([]);
+      const rebuilt = { doc: load(composeOf(result.outputs.get("docker"))) as Json };
+      const after = collector(rebuilt.doc);
+      expect(load(after.config)).toEqual(load(config));
+      const before = (doc.services as Record<string, Json>)[service]!;
+      const back = (rebuilt.doc.services as Record<string, Json>)[after.service]!;
+      expect(back.image).toBe(before.image);
+      expect(back.command).toEqual(before.command);
+      expect(back.ports).toEqual(before.ports);
+      expect(back.restart).toBe(before.restart);
+      expect((back.configs as Json[])[0]!.target).toBe(COLLECTOR_CONFIG_PATH);
+    } finally {
+      rmSync(fileProject.dir, { recursive: true, force: true });
+      rmSync(liveProject.dir, { recursive: true, force: true });
+    }
+  });
+
+  test("without a context the export keeps the content as read, and offers a reparse", async () => {
+    const { doc } = await compose(SOURCE);
+    const { service, config } = collector(doc);
+    const svc = (doc.services as Record<string, Json>)[service]!;
+    const ir = await exportResources({ environment: "test" }, engine("test", service, svc, config));
+    const cfg = ir.resources.find((r) => r.type === "config")!;
+    expect(cfg.properties.content).toBe(config);
+    expect(typeof ir.reparse).toBe("function");
+  });
+
+  test("only a config's content that is a document is offered", () => {
+    const probe = new EmbeddedImports([], { quiet: true });
+    const compose = [
+      "services:",
+      "  app:",
+      "    image: x",
+      "    configs: [{ source: motd, target: /etc/motd }, { source: settings, target: /etc/app.yaml }, { source: fromfile }]",
+      "configs:",
+      "  motd: { content: \"hello there\" }",
+      "  settings: { content: \"a: 1\\n\" }",
+      "  fromfile: { file: ./x.yaml }",
+    ].join("\n");
+    new DockerParser().parse(compose, { embedded: probe });
+    expect(probe.offered.map((c) => [c.location, c.directory])).toEqual([["config settings content", "app"]]);
+  });
+});

package/src/import/embedded.ts

@@ -0,0 +1,83 @@
+/**
+ * Where a Compose file embeds another lexicon's content, for `chant import`
+ * (#3373, #4388).
+ *
+ * A top-level config with `content` is a file Compose writes into each
+ * container that mounts it. The parser offers that text to core's
+ * embedded-content resolver, as k8s offers a ConfigMap value (#2962) and fly
+ * a machine file. `DockerOtelCollector` carries its collector config this way,
+ * at the otel lexicon's `COLLECTOR_CONFIG_PATH`, so a file or live import of
+ * the project gives the same otel source `chant import config.yaml` gives.
+ *
+ * Which lexicon imports the content is decided by core at run time; the hint
+ * below only names the owner a warning suggests when none is installed.
+ */
+
+import type { EmbeddedContent, EmbeddedContentResolver } from "@intentius/chant/import/embedded";
+import { embeddedDocument } from "@intentius/chant/import/embedded";
+import { COLLECTOR_CONFIG_PATH } from "@intentius/chant-lexicon-otel";
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+const COLLECTOR = { lexicon: "otel", what: "an OpenTelemetry Collector config" } as const;
+
+function hintFor(targets: string[], doc: unknown): EmbeddedContent["expectedOwner"] {
+  if (targets.includes(COLLECTOR_CONFIG_PATH)) return COLLECTOR;
+  if (isRecord(doc) && isRecord(doc.service) && isRecord(doc.service.pipelines)) return COLLECTOR;
+  return undefined;
+}
+
+/** Each service's mounts of top-level configs: config name, then the services and targets that mount it. */
+function mountsByConfig(services: Record<string, unknown> | undefined): Map<string, Array<{ service: string; target: string }>> {
+  const out = new Map<string, Array<{ service: string; target: string }>>();
+  for (const [service, raw] of Object.entries(services ?? {})) {
+    if (!isRecord(raw) || !Array.isArray(raw.configs)) continue;
+    for (const c of raw.configs) {
+      const source = typeof c === "string" ? c : isRecord(c) && typeof c.source === "string" ? c.source : undefined;
+      if (!source) continue;
+      const target = isRecord(c) && typeof c.target === "string" ? c.target : `/${source}`;
+      const list = out.get(source) ?? [];
+      list.push({ service, target });
+      out.set(source, list);
+    }
+  }
+  return out;
+}
+
+/**
+ * Offer each top-level config's `content` to `embedded`, replacing the value
+ * an owner imports with its reference. `configs` maps config name to its IR
+ * properties and is changed in place with fresh copies; `services` is the
+ * compose document's services section, read for where each config is mounted.
+ *
+ * The owner's modules go in a directory named after the one service that
+ * mounts the config, else after the config, so a file import and a live
+ * import (which cannot recover the config's key) write them to the same place.
+ */
+export function delegateEmbedded(
+  configs: Map<string, Record<string, unknown>>,
+  services: Record<string, unknown> | undefined,
+  embedded: EmbeddedContentResolver,
+): void {
+  const mounts = mountsByConfig(services);
+  for (const [name, props] of configs) {
+    const text = props.content;
+    if (typeof text !== "string") continue;
+    const doc = embeddedDocument(text);
+    if (!isRecord(doc)) continue;
+    const users = mounts.get(name) ?? [];
+    const owners = new Set(users.map((u) => u.service));
+    const ref = embedded.resolve({
+      host: "docker",
+      hostType: "config",
+      location: `config ${name} content`,
+      directory: owners.size === 1 ? [...owners][0]! : name,
+      text,
+      document: doc,
+      expectedOwner: hintFor(users.map((u) => u.target), doc),
+    });
+    if (ref) configs.set(name, { ...props, content: ref });
+  }
+}

package/src/import/engine.ts

@@ -0,0 +1,107 @@
+/**
+ * A read-only Docker Engine API client for live export (#4388), and the tar
+ * reader for `GET /containers/{id}/archive`.
+ *
+ * The client is a single function, `(path) => { status, body }`, so tests hand
+ * export a fake Engine and never need a daemon. The default one speaks HTTP
+ * over the socket `DOCKER_HOST` names (`unix://…`, or plain `tcp://host:port`),
+ * else `/var/run/docker.sock`, with the unversioned API paths the daemon
+ * serves at its own version.
+ */
+
+import { request } from "node:http";
+
+/** One GET against the Engine API. `path` starts with `/`. */
+export type DockerEngine = (path: string, signal?: AbortSignal) => Promise<{ status: number; body: Buffer }>;
+
+const DEFAULT_SOCKET = "/var/run/docker.sock";
+
+/** Where `DOCKER_HOST` points: a unix socket path, or a host and port. */
+export function engineAddress(dockerHost = process.env.DOCKER_HOST): { socketPath: string } | { host: string; port: number } {
+  if (!dockerHost) return { socketPath: DEFAULT_SOCKET };
+  if (dockerHost.startsWith("unix://")) return { socketPath: dockerHost.slice("unix://".length) };
+  if (dockerHost.startsWith("tcp://")) {
+    if (process.env.DOCKER_TLS_VERIFY) {
+      throw new Error("docker live export: DOCKER_TLS_VERIFY is set, and a TLS Engine endpoint is not supported; use a unix socket or a plain tcp:// endpoint");
+    }
+    const url = new URL(`http://${dockerHost.slice("tcp://".length)}`);
+    return { host: url.hostname, port: Number(url.port || 2375) };
+  }
+  throw new Error(`docker live export: DOCKER_HOST ${dockerHost} is not a unix:// or tcp:// endpoint`);
+}
+
+/** The Engine at `DOCKER_HOST` (or the default socket). */
+export function defaultDockerEngine(dockerHost?: string): DockerEngine {
+  const address = engineAddress(dockerHost);
+  return (path, signal) =>
+    new Promise((resolve, reject) => {
+      const req = request({ ...address, path, method: "GET", headers: { Host: "docker" }, signal }, (res) => {
+        const chunks: Buffer[] = [];
+        res.on("data", (c: Buffer) => chunks.push(c));
+        res.on("end", () => resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks) }));
+        res.on("error", reject);
+      });
+      req.on("error", reject);
+      req.end();
+    });
+}
+
+/** One entry of a tar stream. `type` is the ustar typeflag (`0` file, `5` directory, …). */
+export interface TarEntry {
+  name: string;
+  type: string;
+  data: Buffer;
+}
+
+function field(block: Buffer, start: number, length: number): string {
+  const raw = block.subarray(start, start + length);
+  const end = raw.indexOf(0);
+  return raw.subarray(0, end === -1 ? raw.length : end).toString("utf8");
+}
+
+/** The entries of an uncompressed tar stream. PAX and GNU long-name records are applied to the entry after them. */
+export function readTar(tar: Buffer): TarEntry[] {
+  const out: TarEntry[] = [];
+  let offset = 0;
+  let longName: string | undefined;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((b) => b === 0)) break;
+    const size = parseInt(field(header, 124, 12).trim() || "0", 8);
+    const type = field(header, 156, 1) || "0";
+    const prefix = field(header, 345, 155);
+    let name = prefix ? `${prefix}/${field(header, 0, 100)}` : field(header, 0, 100);
+    const data = tar.subarray(offset + 512, offset + 512 + size);
+    offset += 512 + Math.ceil(size / 512) * 512;
+
+    if (type === "x") {
+      const path = /(?:^|\n)\d+ path=([^\n]*)\n/.exec(data.toString("utf8"));
+      if (path) longName = path[1];
+      continue;
+    }
+    if (type === "L") {
+      longName = data.toString("utf8").replace(/\0+$/, "");
+      continue;
+    }
+    if (type === "g") continue;
+    if (longName !== undefined) {
+      name = longName;
+      longName = undefined;
+    }
+    out.push({ name, type: type === "\0" ? "0" : type, data: Buffer.from(data) });
+  }
+  return out;
+}
+
+/**
+ * The text of the one regular file an archive holds, or undefined when it
+ * holds anything else (a directory, a link, several entries) or the bytes
+ * are not UTF-8 text.
+ */
+export function singleFileText(tar: Buffer): string | undefined {
+  const entries = readTar(tar);
+  if (entries.length !== 1 || entries[0]!.type !== "0") return undefined;
+  const bytes = entries[0]!.data;
+  const text = bytes.toString("utf8");
+  return Buffer.from(text, "utf8").equals(bytes) ? text : undefined;
+}

package/src/import/generator.ts

@@ -4,6 +4,7 @@
  * Converts parsed IR to valid chant TypeScript source code.
  */
 
+import { EmbeddedImportScope, isEmbeddedReference, renderEmbeddedReference, type EmbeddedReference } from "@intentius/chant/import/embedded";
 import type { DockerIR, ServiceIR, VolumeIR, NetworkIR, ConfigIR, SecretIR, DockerfileIR } from "./parser";
 
 export interface GenerateResult {
@@ -21,16 +22,21 @@ export class DockerGenerator {
     const lines: string[] = [];
     const names = new ExportNames();
 
-    for (const entity of entities) {
+    // Export names first, so the imports an embedded reference needs (#3373)
+    // never take one.
+    const exportNames = entities.map((e) => (e.kind === "dockerfile" ? sanitizeName(e.name) : names.take(e.name, e.kind)));
+    const scope = new EmbeddedImportScope("", [...RESERVED, ...exportNames]);
+
+    entities.forEach((entity, i) => {
       if (entity.kind === "dockerfile") {
         imports.add("Dockerfile");
         lines.push(generateDockerfile(entity, warnings));
-        continue;
+        return;
       }
       const ctor = CONSTRUCTORS[entity.kind];
       imports.add(ctor);
-      const exportName = names.take(entity.name, entity.kind);
-      const expr = `new ${ctor}(${propsLiteral(entity)})`;
+      const exportName = exportNames[i]!;
+      const expr = `new ${ctor}(${propsLiteral(entity, scope)})`;
       // An export name that differs from the compose key would rename the
       // key on build, and every reference to it by name would dangle, so
       // the key is set explicitly (#3937).
@@ -40,10 +46,10 @@ export class DockerGenerator {
         imports.add("composeKey");
         lines.push(`export const ${exportName} = composeKey(${JSON.stringify(entity.name)}, ${expr});`);
       }
-    }
+    });
 
     const importLine = `import { ${[...imports].sort().join(", ")} } from "@intentius/chant-lexicon-docker";`;
-    const source = [importLine, "", ...lines].join("\n");
+    const source = [importLine, ...scope.lines(), "", ...lines].join("\n");
 
     return { source, warnings };
   }
@@ -57,11 +63,37 @@ const CONSTRUCTORS = {
   secret: "DockerSecret",
 } as const;
 
-function propsLiteral(entity: ServiceIR | VolumeIR | NetworkIR | ConfigIR | SecretIR): string {
-  if (entity.kind === "service") {
-    return JSON.stringify(entity.props, null, 2).replace(/"([a-z_][a-z0-9_]*)":/g, "$1:");
+function propsLiteral(entity: ServiceIR | VolumeIR | NetworkIR | ConfigIR | SecretIR, scope: EmbeddedImportScope): string {
+  // Embedded references (a config's `content` another lexicon imported) are
+  // rendered as expressions in place of a placeholder string.
+  const refs: EmbeddedReference[] = [];
+  const props = withPlaceholders(entity.props, refs) as Record<string, unknown>;
+  let out: string;
+  if (entity.kind === "service" || refs.length > 0) {
+    out = JSON.stringify(props, null, 2).replace(/"([a-z_][a-z0-9_]*)":/g, "$1:");
+  } else {
+    out = Object.keys(props).length > 0 ? JSON.stringify(props) : "{}";
+  }
+  refs.forEach((ref, i) => {
+    out = out.replace(JSON.stringify(placeholder(i)), () => renderEmbeddedReference(ref, scope, 2));
+  });
+  return out;
+}
+
+function placeholder(i: number): string {
+  return `\u0000chant-embedded-${i}\u0000`;
+}
+
+function withPlaceholders(value: unknown, refs: EmbeddedReference[]): unknown {
+  if (isEmbeddedReference(value)) {
+    refs.push(value);
+    return placeholder(refs.length - 1);
+  }
+  if (Array.isArray(value)) return value.map((v) => withPlaceholders(v, refs));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([k, v]) => [k, withPlaceholders(v, refs)]));
   }
-  return Object.keys(entity.props).length > 0 ? JSON.stringify(entity.props) : "{}";
+  return value;
 }
 
 /** Words an export cannot be named, and the names the generated file imports. */