@deterministic-code/datasources-cli 0.0.0-stage → 0.1.3

package/node_modules/@deterministic-code/rust-generators/src/struct-default.ts

@@ -0,0 +1,99 @@
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import type {
+  IDeterministic,
+  Type,
+  TypeField,
+} from "./specification-parser.ts";
+import {
+  emitViewFields,
+  isAlias,
+  isUnionEnum,
+  wrapsInheritedDatasource,
+} from "./common/view-shape.ts";
+import { rustSpecDefaultExpr } from "./deterministic-type-converter.ts";
+
+const hasNonZeroDefault = (
+  fields: readonly TypeField[],
+  typesByName: ReadonlyMap<string, Type>,
+): boolean =>
+  fields.some(
+    (field) =>
+      field.kind === "primitive" &&
+      rustSpecDefaultExpr(fieldTypeOf(field, typesByName), field) !== undefined,
+  );
+
+const directNested = (fields: readonly TypeField[]): string[] =>
+  fields
+    .filter(
+      (field) =>
+        field.kind === "type" &&
+        !field.isArray &&
+        field.isMap !== true &&
+        !field.isNullable,
+    )
+    .map((field) => field.base);
+
+export const typesNeedingDefault = (deterministic: IDeterministic): Set<string> => {
+  const typesByName = new Map(
+    deterministic.expandedTypes.map((type) => [type.name, type]),
+  );
+  const datasourceNames = new Set(
+    datasourceTypesOf(deterministic).map((type) => type.name),
+  );
+  const expandedViews = new Map(
+    viewTypesOf(deterministic).map((view) => [view.name, view]),
+  );
+  const nestedByType = new Map<string, string[]>();
+  const seeds: string[] = [];
+
+  const consider = (
+    name: string,
+    fields: readonly TypeField[],
+    extraNested: readonly string[],
+  ): void => {
+    nestedByType.set(name, [...extraNested, ...directNested(fields)]);
+    if (hasNonZeroDefault(fields, typesByName)) seeds.push(name);
+  };
+
+  for (const table of datasourceTypesOf(deterministic)) {
+    consider(table.name, persistedColumnFields(table, typesByName), []);
+  }
+
+  for (const view of authoredViewTypesOf(deterministic)) {
+    if (isUnionEnum(view)) continue;
+    const expanded = expandedViews.get(view.name);
+    const fields = emitViewFields(view, expanded, datasourceNames);
+    const extraNested: string[] = [];
+    if (isAlias(view) && fields.length > 0) extraNested.push(view.name);
+    else if (
+      view.inherits !== undefined &&
+      wrapsInheritedDatasource(view, datasourceNames)
+    ) {
+      extraNested.push(view.inherits);
+    }
+    const alias = isAlias(view) && fields.length === 0 && extraNested.length === 0;
+    if (alias) continue;
+    consider(view.name, fields, extraNested);
+  }
+
+  const needing = new Set(seeds);
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const [name, nested] of nestedByType) {
+      if (!needing.has(name)) continue;
+      for (const nestedName of nested) {
+        if (!nestedByType.has(nestedName) || needing.has(nestedName)) continue;
+        needing.add(nestedName);
+        grew = true;
+      }
+    }
+  }
+  return needing;
+};

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/Cargo.toml.tmpl

@@ -0,0 +1,34 @@
+[package]
+name = "{{crateIdent}}"
+version = "0.1.0"
+edition = "2021"
+default-run = "{{crateIdent}}"
+# autobins off: every extra binary is wired by the step that owns it (migrate → MIGRATE_BIN, perf → PERF_BIN), so un-patched merges leave bin sources inert instead of breaking the build.
+autobins = false
+
+[lib]
+name = "{{crateIdent}}"
+path = "src/lib.rs"
+
+[[bin]]
+name = "{{crateIdent}}"
+path = "src/main.rs"
+
+# === BEGIN MIGRATE_BIN — see PATCH_PLAN in create-migrate-scripts.mjs ===
+# === END MIGRATE_BIN ===
+
+# === BEGIN PERF_BIN — see PATCH_PLAN in create-migrate-scripts.mjs ===
+# === END PERF_BIN ===
+
+[dependencies]
+tokio = { version = "1", features = ["full"] }
+# === BEGIN MIGRATE_DEPS — see PATCH_PLAN in create-migrate-scripts.mjs ===
+# === END MIGRATE_DEPS ===
+
+[dev-dependencies]
+http-body-util = "0.1"
+jsonschema = "0.18"
+once_cell = "1"
+reqwest = { version = "0.12", features = ["json", "blocking"] }
+serde_yaml = "0.9"
+tower = { version = "0.5", features = ["util"] }

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/Dockerfile.tmpl

@@ -0,0 +1,31 @@
+# syntax=docker/dockerfile:1
+# Stage 1: build
+FROM rust:1.88-slim AS builder
+RUN apt-get update && apt-get install -y --no-install-recommends pkg-config libssl-dev ca-certificates && rm -rf /var/lib/apt/lists/*
+ADD https://github.com/mozilla/sccache/releases/download/v0.8.2/sccache-v0.8.2-x86_64-unknown-linux-musl.tar.gz /tmp/sccache.tar.gz
+RUN tar -xzf /tmp/sccache.tar.gz -C /tmp && mv /tmp/sccache-v0.8.2-x86_64-unknown-linux-musl/sccache /usr/local/bin/sccache && chmod +x /usr/local/bin/sccache
+ENV RUSTC_WRAPPER=sccache SCCACHE_DIR=/sccache CARGO_INCREMENTAL=0
+WORKDIR /app
+COPY Cargo.toml ./
+COPY src ./src
+# === BEGIN MIGRATE_COPY — see PATCH_PLAN in create-migrate-scripts.mjs ===
+# === END MIGRATE_COPY ===
+RUN --mount=type=cache,target=/usr/local/cargo/registry,sharing=locked --mount=type=cache,target=/sccache,sharing=locked cargo build --release
+
+# Stage 2: runtime — extends the builder (keeps cargo + sources + the build cache) so the verify pipeline's in-container `cargo test` runs; mirrors the TS Dockerfile, which ships node + sources + devDependencies for the same reason. A debian-slim runtime strips cargo and fails `docker compose run rust cargo test`.
+FROM builder
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates libssl3 curl sqlite3 && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY --from=builder /app/target/release/{{crateIdent}} /usr/local/bin/{{crateIdent}}
+# === BEGIN MIGRATE_RUNTIME_COPY — see PATCH_PLAN in create-migrate-scripts.mjs ===
+# === END MIGRATE_RUNTIME_COPY ===
+COPY deterministic /app/deterministic
+COPY scripts/entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod +x /usr/local/bin/entrypoint.sh
+ENV PORT=4000
+ENV DETERMINISTIC_DIR=/app/deterministic
+EXPOSE 4000
+HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=12 \
+  CMD curl -fsS -o /dev/null -w 'HTTP %{http_code}\n' http://localhost:4000/api/health || (echo "probe failed" && exit 1)
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+CMD ["{{crateIdent}}"]

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/docker-compose.yml.tmpl

@@ -0,0 +1,17 @@
+rust:
+  build:
+    context: .
+  ports:
+    - '${HOST_PORT:-4002}:4000'
+  environment:
+    - PORT=4000
+    - DETERMINISTIC_DIR=/app/deterministic
+    - DETERMINISTIC_TRACE=${DETERMINISTIC_TRACE:-}
+  healthcheck:
+    test: ['CMD-SHELL', "curl -fsS -o /dev/null -w 'HTTP %{http_code}\\n' http://localhost:4000/api/health || (echo 'probe failed' && exit 1)"]
+    interval: 5s
+    timeout: 3s
+    retries: 12
+    start_period: 10s
+  labels:
+    - 'deterministic.language=rust'

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/entrypoint.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env sh
+set -eu
+
+# === BEGIN MIGRATE_HOOK — see PATCH_PLAN in create-migrate-scripts.mjs ===
+# === END MIGRATE_HOOK ===
+
+exec "$@"

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/env.tmpl

@@ -0,0 +1,2 @@
+PORT=4002
+DETERMINISTIC_DIR=./deterministic

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/gitignore.tmpl

@@ -0,0 +1 @@
+target/

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/rust/chunks/README.md

@@ -0,0 +1 @@
+Source fragments composed into migrate runners. Not standalone-compilable.

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/rust/chunks/lib.rs

@@ -0,0 +1,2 @@
+// === BEGIN MODULES — see PATCH_PLAN in create-migrate-scripts.mjs ===
+// === END MODULES ===

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/rust/chunks/main.rs

@@ -0,0 +1,4 @@
+#[tokio::main]
+async fn main() {
+    println!("{{crateIdent}}");
+}

package/node_modules/@deterministic-code/rust-generators/src/templates/create-backend-app/rust/health_check_service.rs

@@ -0,0 +1,13 @@
+use serde_json::{json, Value};
+
+pub struct HealthCheckService;
+
+impl HealthCheckService {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub async fn check(&self) -> Value {
+        json!({ "status": "ok" })
+    }
+}

package/node_modules/@deterministic-code/rust-generators/src/templates/create-datasource-type-validators/type.rs.tmpl

@@ -0,0 +1,8 @@
+// schema-version: {{schemaVersion}}
+pub fn {{fnName}}({{paramName}}: &{{&typePath}}) -> Result<(), Vec<String>> {
+    {{declared}}: Vec<String> = Vec::new();
+{{#checks}}
+{{&line}}
+{{/checks}}
+    if errors.is_empty() { Ok(()) } else { Err(errors) }
+}

package/node_modules/@deterministic-code/rust-generators/src/templates/create-datasource-type-validators-tests/type_tests.rs.tmpl

@@ -0,0 +1,14 @@
+// schema-version: {{schemaVersion}}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use {{&typeUse}};
+
+{{#cases}}
+    #[test]
+    fn {{ident}}() {
+        let value = {{&fixture}};
+        assert!({{fnName}}(&value).{{assertion}});
+    }
+{{/cases}}
+}

package/node_modules/@deterministic-code/rust-generators/src/templates/create-datasource-types/type.rs.tmpl

@@ -0,0 +1,22 @@
+// schema-version: {{schemaVersion}}
+{{#simpleDoc}}/// Type {{structName}}.
+{{/simpleDoc}}{{#descriptionDoc}}/// Type {{structName}}.
+/// Datasource type: {{datasourceType}}.
+/// Fields: {{fieldCount}}.
+{{/descriptionDoc}}#[derive(Clone, Debug, PartialEq)]
+pub struct {{structName}} {
+{{#fields}}
+    pub {{ident}}: {{rustType}},
+{{/fields}}
+}
+{{#implDefault}}
+impl Default for {{structName}} {
+    fn default() -> Self {
+        Self {
+{{#fields}}
+            {{ident}}: {{&defaultExpr}},
+{{/fields}}
+        }
+    }
+}
+{{/implDefault}}

package/node_modules/@deterministic-code/rust-generators/src/templates/create-datasource-types-tests/type_tests.rs.tmpl

@@ -0,0 +1,39 @@
+// schema-version: {{schemaVersion}}
+#[cfg(test)]
+mod tests {
+    use super::{{fileBase}}::*;
+
+    fn sample() -> {{structName}} {
+        {{structName}} {
+{{#fields}}
+            {{ident}}: {{&sampleExpr}},
+{{/fields}}
+        }
+    }
+
+{{#fields}}
+    #[test]
+    fn {{getsTest}}() {
+        let initial = {{&sampleExpr}};
+        let mut value = sample();
+        value.{{ident}} = initial.clone();
+        assert_eq!(value.{{ident}}, initial);
+    }
+
+    #[test]
+    fn {{setsTest}}() {
+        let mut value = sample();
+        let next = {{&nextExpr}};
+        value.{{ident}} = next.clone();
+        assert_eq!(value.{{ident}}, next);
+    }
+{{#nullable}}
+    #[test]
+    fn {{allowsNoneTest}}() {
+        let mut value = sample();
+        value.{{ident}} = None;
+        assert!(value.{{ident}}.is_none());
+    }
+{{/nullable}}
+{{/fields}}
+}

package/node_modules/@deterministic-code/rust-generators/src/templates/create-openapi/openapi.rs.tmpl

@@ -0,0 +1,17 @@
+use axum::http::header::CONTENT_TYPE;
+use axum::response::{IntoResponse, Response};
+use axum::routing::get;
+
+const OPENAPI_JSON: &str = "{{&specJson}}";
+
+pub fn router() -> axum::Router {
+    axum::Router::new().route("/openapi.json", get(serve_openapi))
+}
+
+async fn serve_openapi() -> Response {
+    (
+        [(CONTENT_TYPE, "application/json")],
+        OPENAPI_JSON.to_string(),
+    )
+        .into_response()
+}

package/node_modules/@deterministic-code/rust-generators/src/templates/create-openapi/openapi_conformance.rs.tmpl

@@ -0,0 +1,56 @@
+use {{crateModule}}::routes::openapi;
+use reqwest::StatusCode;
+use serde_json::Value;
+use tokio::net::TcpListener;
+
+async fn serve_openapi() -> String {
+    let router = openapi::router();
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
+    let addr = listener.local_addr().expect("addr");
+    tokio::spawn(async move {
+        let _ = axum::serve(listener, router).await;
+    });
+    format!("http://{}", addr)
+}
+
+#[tokio::test]
+async fn openapi_endpoint_returns_valid_spec_document() {
+    let base = serve_openapi().await;
+    let resp = reqwest::get(format!("{}/openapi.json", base))
+        .await
+        .expect("GET /openapi.json");
+    assert_eq!(resp.status(), StatusCode::OK);
+    assert_eq!(
+        resp.headers()
+            .get("content-type")
+            .and_then(|v| v.to_str().ok())
+            .map(|v| v.to_string()),
+        Some("application/json".to_string())
+    );
+    let body: Value = resp.json().await.expect("json");
+    assert_eq!(body.get("openapi").and_then(|v| v.as_str()), Some("3.0.3"));
+    assert!(body.get("info").is_some(), "info missing");
+    assert!(body.get("paths").is_some(), "paths missing");
+}
+
+#[tokio::test]
+async fn openapi_paths_cover_every_generated_entity() {
+    let base = serve_openapi().await;
+    let body: Value = reqwest::get(format!("{}/openapi.json", base))
+        .await
+        .expect("GET")
+        .json()
+        .await
+        .expect("json");
+    let paths = body.get("paths").and_then(|v| v.as_object()).expect("paths");
+    let expected: &[&str] = &[
+{{&expectedPaths}}
+    ];
+    for path in expected {
+        assert!(
+            paths.contains_key(*path),
+            "openapi.paths missing entry for {}",
+            path
+        );
+    }
+}