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

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes/coerce-row.rs.tmpl

@@ -0,0 +1,62 @@
+fn coerce_row_types(row: &mut RowMap) {
+    let bool_cols: &[&str] = {{{boolCols}}};
+    let binary_cols: &[&str] = {{{binCols}}};
+    for col in bool_cols {
+        if let Some(v) = row.get(*col).cloned() {
+            match v {
+                Value::Number(n) => {
+                    if let Some(i) = n.as_i64() {
+                        row.insert((*col).to_string(), Value::Bool(i != 0));
+                    }
+                }
+                Value::Bool(_) | Value::Null => {}
+                _ => {}
+            }
+        }
+    }
+    for col in binary_cols {
+        if let Some(v) = row.get(*col).cloned() {
+            match v {
+                Value::Array(arr) => {
+                    let bytes: Vec<u8> = arr
+                        .iter()
+                        .filter_map(|x| x.as_u64().and_then(|n| u8::try_from(n).ok()))
+                        .collect();
+                    let encoded = base64_encode(&bytes);
+                    row.insert((*col).to_string(), Value::String(encoded));
+                }
+                Value::Null | Value::String(_) => {}
+                _ => {}
+            }
+        }
+    }
+}
+
+fn base64_encode(bytes: &[u8]) -> String {
+    const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let mut out = String::with_capacity((bytes.len() + 2) / 3 * 4);
+    let mut i = 0;
+    while i + 3 <= bytes.len() {
+        let n = ((bytes[i] as u32) << 16) | ((bytes[i + 1] as u32) << 8) | (bytes[i + 2] as u32);
+        out.push(CHARSET[((n >> 18) & 0x3f) as usize] as char);
+        out.push(CHARSET[((n >> 12) & 0x3f) as usize] as char);
+        out.push(CHARSET[((n >> 6) & 0x3f) as usize] as char);
+        out.push(CHARSET[(n & 0x3f) as usize] as char);
+        i += 3;
+    }
+    let rem = bytes.len() - i;
+    if rem == 1 {
+        let n = (bytes[i] as u32) << 16;
+        out.push(CHARSET[((n >> 18) & 0x3f) as usize] as char);
+        out.push(CHARSET[((n >> 12) & 0x3f) as usize] as char);
+        out.push('=');
+        out.push('=');
+    } else if rem == 2 {
+        let n = ((bytes[i] as u32) << 16) | ((bytes[i + 1] as u32) << 8);
+        out.push(CHARSET[((n >> 18) & 0x3f) as usize] as char);
+        out.push(CHARSET[((n >> 12) & 0x3f) as usize] as char);
+        out.push(CHARSET[((n >> 6) & 0x3f) as usize] as char);
+        out.push('=');
+    }
+    out
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes/crud.rs.tmpl

@@ -0,0 +1 @@
+pub fn router() {}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes/readonly.rs.tmpl

@@ -0,0 +1 @@
+pub fn router() {}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes/validator-empty.rs.tmpl

@@ -0,0 +1 @@
+fn {{fnName}}(_body: &RowMap) -> Result<(), Vec<String>> { Ok(()) }

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes/validator.rs.tmpl

@@ -0,0 +1,5 @@
+fn {{fnName}}(body: &RowMap) -> Result<(), Vec<String>> {
+    let mut errors: Vec<String> = Vec::new();
+{{{checks}}}
+    if errors.is_empty() { Ok(()) } else { Err(errors) }
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-e2e/app_routes_e2e.rs.tmpl

@@ -0,0 +1,2 @@
+#[test]
+fn app_routes_placeholder() {}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-e2e/crud-tests.rs.tmpl

@@ -0,0 +1,66 @@
+#[tokio::test]
+async fn {{listTest}}() {
+    let router = {{setupFn}}();
+    let req = HttpRequest::builder()
+        .method("GET")
+        .uri("/api/{{segment}}")
+        .body(Body::empty())
+        .unwrap();
+    let res = router.oneshot(req).await.unwrap();
+    assert_eq!(
+        res.status(),
+        StatusCode::OK,
+        "{{pascal}} list expected 200, got {}",
+        res.status()
+    );
+}
+
+#[tokio::test]
+async fn {{postTest}}() {
+    let router = {{setupFn}}();
+    let req = HttpRequest::builder()
+        .method("POST")
+        .uri("/api/{{segment}}")
+        .header("content-type", "application/json")
+        .body(Body::from(r#"{{{payload}}}"#))
+        .unwrap();
+    let res = router.oneshot(req).await.unwrap();
+    assert!(
+        res.status() == StatusCode::CREATED || res.status() == StatusCode::BAD_REQUEST,
+        "{{pascal}} POST expected 201 or 400, got {}",
+        res.status()
+    );
+}
+
+#[tokio::test]
+async fn {{getMissingTest}}() {
+    let router = {{setupFn}}();
+    let req = HttpRequest::builder()
+        .method("GET")
+        .uri("/api/{{segment}}/{{missing}}")
+        .body(Body::empty())
+        .unwrap();
+    let res = router.oneshot(req).await.unwrap();
+    assert_eq!(
+        res.status(),
+        StatusCode::NOT_FOUND,
+        "{{pascal}} GET missing expected 404, got {}",
+        res.status()
+    );
+}
+
+#[tokio::test]
+async fn {{deleteMissingTest}}() {
+    let router = {{setupFn}}();
+    let req = HttpRequest::builder()
+        .method("DELETE")
+        .uri("/api/{{segment}}/{{missing}}")
+        .body(Body::empty())
+        .unwrap();
+    let res = router.oneshot(req).await.unwrap();
+    assert!(
+        res.status().as_u16() < 500,
+        "{{pascal}} DELETE missing expected non-5xx, got {}",
+        res.status()
+    );
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-e2e/readonly-tests.rs.tmpl

@@ -0,0 +1,33 @@
+#[tokio::test]
+async fn {{listTest}}() {
+    let router = {{setupFn}}();
+    let req = HttpRequest::builder()
+        .method("GET")
+        .uri("/api/{{segment}}")
+        .body(Body::empty())
+        .unwrap();
+    let res = router.oneshot(req).await.unwrap();
+    assert_eq!(
+        res.status(),
+        StatusCode::OK,
+        "{{pascal}} list expected 200, got {}",
+        res.status()
+    );
+}
+
+#[tokio::test]
+async fn {{getMissingTest}}() {
+    let router = {{setupFn}}();
+    let req = HttpRequest::builder()
+        .method("GET")
+        .uri("/api/{{segment}}/{{missing}}")
+        .body(Body::empty())
+        .unwrap();
+    let res = router.oneshot(req).await.unwrap();
+    assert_eq!(
+        res.status(),
+        StatusCode::NOT_FOUND,
+        "{{pascal}} GET missing expected 404, got {}",
+        res.status()
+    );
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-e2e/setup.rs.tmpl

@@ -0,0 +1,52 @@
+fn {{setupFn}}() -> axum::Router {
+    let svc: std::sync::Arc<dyn DynamicService> = std::sync::Arc::new(
+        InMemoryDynamicService::new(),
+    );
+    let registry = ServiceRegistryBuilder::new()
+        .register("{{entity}}", svc)
+        .build();
+    let specs = vec![
+        GenericRouteSpec {
+            route_name: "{{listRouteName}}".to_string(),
+            path: "/api/{{segment}}".to_string(),
+            method: HttpMethod::Get,
+            service: "{{entity}}".to_string(),
+            service_method: "findAll".to_string(),
+            response_format: Some(ResponseFormat::Items),
+            status_code: None,
+            aliases: vec![],
+        },
+        GenericRouteSpec {
+            route_name: "{{getByIdRouteName}}".to_string(),
+            path: "/api/{{segment}}/:id".to_string(),
+            method: HttpMethod::Get,
+            service: "{{entity}}".to_string(),
+            service_method: "findById".to_string(),
+            response_format: Some(ResponseFormat::Item),
+            status_code: None,
+            aliases: vec![],
+        },
+        GenericRouteSpec {
+            route_name: "{{createRouteName}}".to_string(),
+            path: "/api/{{segment}}".to_string(),
+            method: HttpMethod::Post,
+            service: "{{entity}}".to_string(),
+            service_method: "create".to_string(),
+            response_format: Some(ResponseFormat::Item),
+            status_code: None,
+            aliases: vec![],
+        },
+        GenericRouteSpec {
+            route_name: "{{deleteByIdRouteName}}".to_string(),
+            path: "/api/{{segment}}/:id".to_string(),
+            method: HttpMethod::Delete,
+            service: "{{entity}}".to_string(),
+            service_method: "delete".to_string(),
+            response_format: None,
+            status_code: None,
+            aliases: vec![],
+        },
+    ];
+    let (router, _report) = build_router(&specs, &registry);
+    router
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-tests/by-field-get-list.rs.tmpl

@@ -0,0 +1,15 @@
+
+    #[tokio::test]
+    async fn {{byFieldListTest}}() {
+        let res = setup()
+            .oneshot(
+                Request::builder()
+                    .method("GET")
+                    .uri("{{mountPath}}/{{kebab}}/x")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+    }

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-tests/by-field-get-unique.rs.tmpl

@@ -0,0 +1,15 @@
+
+    #[tokio::test]
+    async fn {{byFieldMissingTest}}() {
+        let res = setup()
+            .oneshot(
+                Request::builder()
+                    .method("GET")
+                    .uri("{{mountPath}}/{{kebab}}/missing")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::NOT_FOUND);
+    }

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-tests/crud.rs.tmpl

@@ -0,0 +1,9 @@
+#[cfg(test)]
+mod tests {
+    use super::{{fileBase}}::*;
+
+    #[test]
+    fn router_is_defined() {
+        router();
+    }
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-routes-tests/readonly.rs.tmpl

@@ -0,0 +1,9 @@
+#[cfg(test)]
+mod tests {
+    use super::{{fileBase}}::*;
+
+    #[test]
+    fn router_is_defined() {
+        router();
+    }
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-service-integration-tests/generic.rs.tmpl

@@ -0,0 +1,9 @@
+#[cfg(test)]
+mod tests {
+    use super::{{fileBase}}::*;
+
+    #[test]
+    fn constructs() {
+        let _ = {{structName}}::new();
+    }
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-service-tests/generic.rs.tmpl

@@ -0,0 +1,9 @@
+#[cfg(test)]
+mod tests {
+    use super::{{fileBase}}::*;
+
+    #[test]
+    fn constructs() {
+        let _ = {{structName}}::new();
+    }
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-services/custom-stub.rs.tmpl

@@ -0,0 +1,13 @@
+pub struct {{structName}};
+
+impl {{structName}} {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for {{structName}} {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-services/generic.rs.tmpl

@@ -0,0 +1,13 @@
+pub struct {{structName}};
+
+impl {{structName}} {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for {{structName}} {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-view-type-validators/check-array-nullable.rs.tmpl

@@ -0,0 +1 @@
+    if let Some(arr) = &{{access}} { for item in arr { if let Err(mut e) = {{fn}}(item) { errors.append(&mut e); } } }

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-view-type-validators/check-array.rs.tmpl

@@ -0,0 +1 @@
+    for item in &{{access}} { if let Err(mut e) = {{fn}}(item) { errors.append(&mut e); } }

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-view-type-validators/check-nullable.rs.tmpl

@@ -0,0 +1 @@
+    if let Some(inner) = &{{access}} { if let Err(mut e) = {{fn}}(inner) { errors.append(&mut e); } }

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-view-type-validators/check-required.rs.tmpl

@@ -0,0 +1 @@
+    if let Err(mut e) = {{fn}}({{arg}}) { errors.append(&mut e); }

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

@@ -0,0 +1,20 @@
+// schema-version: {{schemaVersion}}
+{{#isUnion}}pub fn {{fnName}}(obj: &{{&typePath}}) -> Result<(), Vec<String>> {
+    match obj {
+{{#arms}}
+        {{&arm}}
+{{/arms}}
+    }
+}
+{{/isUnion}}{{#isShaped}}pub fn {{fnName}}({{paramName}}: &{{&typePath}}) -> Result<(), Vec<String>> {
+{{#hasChecks}}
+    let mut errors: Vec<String> = Vec::new();
+{{#checks}}
+{{&line}}
+{{/checks}}
+    if errors.is_empty() { Ok(()) } else { Err(errors) }
+{{/hasChecks}}{{^hasChecks}}
+    Ok(())
+{{/hasChecks}}
+}
+{{/isShaped}}

package/node_modules/@deterministic-code/rust-generators/dist/templates/create-view-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/dist/templates/create-view-types/type.rs.tmpl

@@ -0,0 +1,35 @@
+// schema-version: {{schemaVersion}}
+#[allow(unused_imports)]
+use super::*;
+{{#needsHashMap}}use std::collections::HashMap;
+{{/needsHashMap}}
+{{#simpleDoc}}/// View {{structName}}.
+{{/simpleDoc}}{{#descriptionDoc}}/// View {{structName}}.
+/// Datasource type: {{datasourceType}}.
+/// Target: {{target}}.
+/// Fields: {{fieldCount}}.
+{{/descriptionDoc}}{{#isAlias}}pub type {{structName}} = {{&aliasType}};
+{{/isAlias}}{{#isUnion}}#[derive(Clone, Debug, PartialEq)]
+pub enum {{structName}} {
+{{#members}}
+    {{variant}}({{&memberType}}),
+{{/members}}
+}
+{{/isUnion}}{{#isStruct}}#[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}}
+{{/isStruct}}

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

@@ -0,0 +1,48 @@
+// schema-version: {{schemaVersion}}
+#[cfg(test)]
+mod tests {
+    use super::{{fileBase}}::*;
+{{#needsHashMap}}    use std::collections::HashMap;
+{{/needsHashMap}}
+
+{{#isShaped}}
+    fn sample() -> {{structName}} {
+        {{&fixture}}
+    }
+
+{{#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}}
+{{/isShaped}}
+{{#isUnion}}
+{{#members}}
+    #[test]
+    fn {{acceptsMemberTest}}() {
+        let value = {{&memberExpr}};
+        let _ok: {{structName}} = value;
+    }
+{{/members}}
+{{/isUnion}}
+}

package/node_modules/@deterministic-code/rust-generators/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@deterministic-code/rust-generators",
+  "version": "0.0.1",
+  "description": "Rust generator pack for the deterministic toolchain.",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    "./generate-context": {
+      "types": "./dist/generate-context.d.js",
+      "import": "./dist/generate-context.js"
+    },
+    "./generate-backend-app": {
+      "types": "./dist/generate-backend-app.d.js",
+      "import": "./dist/generate-backend-app.js"
+    },
+    "./generate-datasource-type-validators": {
+      "types": "./dist/generate-datasource-type-validators.d.js",
+      "import": "./dist/generate-datasource-type-validators.js"
+    },
+    "./generate-datasource-type-validators-tests": {
+      "types": "./dist/generate-datasource-type-validators-tests.d.js",
+      "import": "./dist/generate-datasource-type-validators-tests.js"
+    },
+    "./generate-datasource-types": {
+      "types": "./dist/generate-datasource-types.d.js",
+      "import": "./dist/generate-datasource-types.js"
+    },
+    "./generate-datasource-types-tests": {
+      "types": "./dist/generate-datasource-types-tests.d.js",
+      "import": "./dist/generate-datasource-types-tests.js"
+    },
+    "./generate-openapi": {
+      "types": "./dist/generate-openapi.d.js",
+      "import": "./dist/generate-openapi.js"
+    },
+    "./generate-perf-e2e-tests": {
+      "types": "./dist/generate-perf-e2e-tests.d.js",
+      "import": "./dist/generate-perf-e2e-tests.js"
+    },
+    "./generate-perf-server": {
+      "types": "./dist/generate-perf-server.d.js",
+      "import": "./dist/generate-perf-server.js"
+    },
+    "./generate-routes": {
+      "types": "./dist/generate-routes.d.js",
+      "import": "./dist/generate-routes.js"
+    },
+    "./generate-routes-e2e-test": {
+      "types": "./dist/generate-routes-e2e-test.d.js",
+      "import": "./dist/generate-routes-e2e-test.js"
+    },
+    "./generate-routes-tests": {
+      "types": "./dist/generate-routes-tests.d.js",
+      "import": "./dist/generate-routes-tests.js"
+    },
+    "./generate-service-integration-tests": {
+      "types": "./dist/generate-service-integration-tests.d.js",
+      "import": "./dist/generate-service-integration-tests.js"
+    },
+    "./generate-service-tests": {
+      "types": "./dist/generate-service-tests.d.js",
+      "import": "./dist/generate-service-tests.js"
+    },
+    "./generate-services": {
+      "types": "./dist/generate-services.d.js",
+      "import": "./dist/generate-services.js"
+    },
+    "./generate-view-type-validators": {
+      "types": "./dist/generate-view-type-validators.d.js",
+      "import": "./dist/generate-view-type-validators.js"
+    },
+    "./generate-view-type-validators-tests": {
+      "types": "./dist/generate-view-type-validators-tests.d.js",
+      "import": "./dist/generate-view-type-validators-tests.js"
+    },
+    "./generate-view-types": {
+      "types": "./dist/generate-view-types.d.js",
+      "import": "./dist/generate-view-types.js"
+    },
+    "./generate-view-types-tests": {
+      "types": "./dist/generate-view-types-tests.d.js",
+      "import": "./dist/generate-view-types-tests.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.js",
+      "import": "./dist/*.js"
+    },
+    "./*/*": {
+      "types": "./dist/*/*.d.js",
+      "import": "./dist/*/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "tsconfig.build.json"
+  ],
+  "dependencies": {
+    "@deterministic-code/deterministic-generators-common": "0.1.0",
+    "@deterministic-code/generators-common": "0.0.1",
+    "@deterministic-code/generators-openapi": "0.0.1",
+    "mustache": "^4.2.0",
+    "pluralize": "^8.0.0",
+    "yaml": "^2.6.0"
+  }
+}

package/node_modules/@deterministic-code/rust-generators/src/common/default-casing.test.ts

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createCasing } from "./default-casing.ts";
+
+const NAME = "notification_type";
+
+describe("createCasing Auto defaults", () => {
+  it("matches Default Casings for Rust", () => {
+    const casing = createCasing({});
+    assert.equal(casing.convertFileName(NAME), "notificationType");
+    assert.equal(casing.convertTypes(NAME), "NotificationType");
+    assert.equal(casing.convertFields(NAME), "notification_type");
+    assert.equal(casing.convertDirectories(NAME), "notificationType");
+    assert.equal(casing.filePath(NAME), "notificationType.rs");
+    assert.equal(casing.serviceClassName("user"), "UserService");
+    assert.equal(
+      casing.fnIdent("validate_create_user"),
+      "validate_create_user",
+    );
+  });
+});
+
+describe("createCasing overrides", () => {
+  it("snakes file names", () => {
+    const casing = createCasing({
+      "languages.rust.casing.file_names": "Snake",
+    });
+    assert.equal(casing.filePath(NAME), "notification_type.rs");
+  });
+
+  it("pascals file names", () => {
+    const casing = createCasing({
+      "languages.rust.casing.file_names": "Pascal",
+    });
+    assert.equal(casing.filePath(NAME), "NotificationType.rs");
+  });
+
+  it("kebabs directories independently of files", () => {
+    const casing = createCasing({
+      "languages.rust.casing.file_names": "Snake",
+      "languages.rust.casing.directories": "Kebab",
+    });
+    assert.equal(casing.fileBase(NAME), "notification_type");
+    assert.equal(casing.directory(NAME), "notification-type");
+  });
+
+  it("camels fields", () => {
+    const casing = createCasing({
+      "languages.rust.casing.fields": "Camel",
+    });
+    assert.equal(casing.convertFields("role_id"), "roleId");
+  });
+
+  it("pascals fields", () => {
+    const casing = createCasing({
+      "languages.rust.casing.fields": "Pascal",
+    });
+    assert.equal(casing.convertFields("role_id"), "RoleId");
+  });
+});