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

package/node_modules/@deterministic-code/rust-generators/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "nodenext", "moduleResolution": "nodenext", "target": "ES2022",
+    "lib": ["ES2022"], "types": ["node"], "declaration": true, "outDir": "dist",
+    "rootDir": "src", "allowImportingTsExtensions": true, "rewriteRelativeImportExtensions": true,
+    "resolveJsonModule": true, "skipLibCheck": true, "strict": true, "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "src/templates/**"]
+}

package/node_modules/@deterministic-code/typescript-generators/dist/client-binding-transport.js

@@ -0,0 +1,15 @@
+const clientRoot = "frontend/src/client";
+const clientBindingRootIndex = `${clientRoot}/index.ts`;
+const clientBindingIndexPath = (kind) => `${clientRoot}/${kind}/index.ts`;
+const clientBindingHttpPath = (kind) => `${clientRoot}/${kind}/http.ts`;
+const clientBindingFilePath = (kind, fileBase) => `${clientRoot}/${kind}/${fileBase}.ts`;
+const clientBindingMockTestPath = (kind, fileBase) => `${clientRoot}/${kind}/${fileBase}.mock.test.ts`;
+const clientBindingLiveTestPath = (kind, fileBase) => `${clientRoot}/${kind}/${fileBase}.live.test.ts`;
+export {
+  clientBindingFilePath,
+  clientBindingHttpPath,
+  clientBindingIndexPath,
+  clientBindingLiveTestPath,
+  clientBindingMockTestPath,
+  clientBindingRootIndex
+};

package/node_modules/@deterministic-code/typescript-generators/dist/client-bindings-ir.js

@@ -0,0 +1,186 @@
+import {
+  namedRoutes
+} from "@deterministic-code/generators-common/routes-api";
+import { loadRoutesApi } from "@deterministic-code/generators-common/routes-api-converter";
+import { createCasing } from "./common/default-casing.js";
+import { httpPathFromRoutesApi } from "./common/http-path.js";
+import { resolvesToSelf } from "./frontend-bindings-routes.js";
+const camelIdent = (name) => name.replace(/_([a-z0-9])/gi, (_, ch) => ch.toUpperCase());
+const pascalIdent = (name) => {
+  const camel = camelIdent(name);
+  return `${camel.slice(0, 1).toUpperCase()}${camel.slice(1)}`;
+};
+const clientBindingsSchema = (settings) => settings["client_bindings.schema"] ?? "self";
+const requireSelfSchema = (settings) => {
+  const schema = clientBindingsSchema(settings);
+  if (!resolvesToSelf(schema)) {
+    throw new Error(
+      `generate-client-bindings: schema ${JSON.stringify(schema)} is not this backend (expected "self" or "id:...")`
+    );
+  }
+};
+const pathParamNames = (path) => {
+  const counts = /* @__PURE__ */ new Map();
+  return [...path.matchAll(/\{([^}]+)\}/g)].map((match) => {
+    const camel = camelIdent(match[1]);
+    const n = (counts.get(camel) ?? 0) + 1;
+    counts.set(camel, n);
+    return n === 1 ? camel : `${camel}_${n}`;
+  });
+};
+const pathExpr = (path, params) => {
+  if (params.length === 0) return JSON.stringify(path);
+  let i = 0;
+  const replaced = path.replace(/\{[^}]+\}/g, () => {
+    const name = params[i++];
+    return `\${encodeURIComponent(String(${name}))}`;
+  });
+  return `\`${replaced}\``;
+};
+const methodNameOf = (routeName, entity) => {
+  if (entity === null) return camelIdent(routeName);
+  const prefix = camelIdent(entity);
+  if (!routeName.startsWith(prefix) || routeName.length === prefix.length) {
+    return camelIdent(routeName);
+  }
+  const rest = routeName.slice(prefix.length);
+  return rest[0].toLowerCase() + rest.slice(1);
+};
+const namedType = (typeName) => {
+  if (typeName === "unknown" || typeName === "void") return void 0;
+  return typeName.endsWith("[]") ? typeName.slice(0, -2) : typeName;
+};
+const bodyName = (body) => body === void 0 ? void 0 : body.name;
+const isListPath = (method, path) => method === "GET" && !/\{[^}]+\}$/.test(path);
+const mutationShape = (params, hasBody, bodyType) => {
+  const fields = [
+    ...params.map((name) => `${name}: string | number`),
+    ...hasBody ? [`body: ${bodyType}`] : []
+  ];
+  if (fields.length === 0) {
+    return { mutationArg: "", mutationCall: "", hasMutationArg: false };
+  }
+  if (fields.length === 1) {
+    return {
+      mutationArg: fields[0],
+      mutationCall: hasBody ? "body" : params[0],
+      hasMutationArg: true
+    };
+  }
+  return {
+    mutationArg: `vars: { ${fields.join("; ")} }`,
+    mutationCall: [
+      ...params.map((name) => `vars.${name}`),
+      ...hasBody ? ["vars.body"] : []
+    ].join(", "),
+    hasMutationArg: true
+  };
+};
+const projectMethod = (routeName, def) => {
+  const pathPattern = httpPathFromRoutesApi(def.path);
+  const params = pathParamNames(pathPattern);
+  const httpMethod = def.method.toUpperCase();
+  const isList = isListPath(httpMethod, pathPattern);
+  const requestName = bodyName(def.request);
+  const responseName = bodyName(def.response);
+  const hasBody = requestName !== void 0;
+  const bodyType = requestName ?? "unknown";
+  const hasResponse = responseName !== void 0;
+  const returnType = !hasResponse ? "void" : isList ? `${responseName}[]` : responseName;
+  const methodName = methodNameOf(routeName, def.entity);
+  const argParts = [
+    ...params.map((name) => `${name}: string | number`),
+    ...hasBody ? [`body: ${bodyType}`] : []
+  ];
+  const callParts = [...params, ...hasBody ? ["body"] : []];
+  const liveParts = [...params.map(() => "1"), ...hasBody ? ["{}"] : []];
+  const typeNames = [namedType(bodyType), namedType(returnType)].filter(
+    (name) => name !== void 0
+  );
+  const method = {
+    methodName,
+    pascalName: pascalIdent(methodName),
+    hookName: pascalIdent(`use_${def.entity ?? "custom"}_${methodName}`),
+    httpMethod,
+    pathPattern,
+    pathExpr: pathExpr(pathPattern, params),
+    params,
+    hasArgs: argParts.length > 0,
+    hasBody,
+    hasResponse,
+    isList,
+    isQuery: httpMethod === "GET",
+    args: argParts.join(", "),
+    callArgs: callParts.join(", "),
+    liveArgs: liveParts.join(", "),
+    liveMutationArg: callParts.length === 0 ? "" : callParts.length === 1 ? liveParts[0] : `{ ${callParts.map((name, i) => `${name}: ${liveParts[i]}`).join(", ")} }`,
+    ...mutationShape(params, hasBody, bodyType),
+    bodyType,
+    returnType,
+    mockReturn: isList ? "[]" : hasResponse ? "{}" : "undefined",
+    queryKeyExpr: `[${[JSON.stringify(def.entity ?? "custom"), JSON.stringify(methodName), ...params].join(", ")}] as const`
+  };
+  return { method, typeNames };
+};
+const projectClientBindings = (doc, typeImport = (typeName) => `../../types/${typeName}`) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [routeName, def] of namedRoutes(doc.routes)) {
+    const fileBase = def.entity ?? "custom";
+    const bucket = grouped.get(fileBase) ?? {
+      fileBase,
+      clientName: camelIdent(`${fileBase}_client`),
+      pascalEntity: pascalIdent(fileBase),
+      methods: [],
+      typeNames: /* @__PURE__ */ new Set()
+    };
+    if (!grouped.has(fileBase)) grouped.set(fileBase, bucket);
+    const projected = projectMethod(routeName, def);
+    bucket.methods.push(projected.method);
+    for (const name of projected.typeNames) bucket.typeNames.add(name);
+  }
+  const entities = [...grouped.values()].sort((a, b) => a.fileBase.localeCompare(b.fileBase)).map((bucket) => ({
+    fileBase: bucket.fileBase,
+    clientName: bucket.clientName,
+    queryOptionsName: camelIdent(`${bucket.fileBase}_client_query_options`),
+    mutationOptionsName: camelIdent(`${bucket.fileBase}_client_mutation_options`),
+    pascalEntity: bucket.pascalEntity,
+    methods: bucket.methods,
+    queries: bucket.methods.filter((method) => method.isQuery),
+    mutations: bucket.methods.filter((method) => !method.isQuery),
+    typeImports: [...bucket.typeNames].sort((a, b) => a.localeCompare(b)).map((typeName) => ({ typeName, importPath: typeImport(typeName) }))
+  }));
+  return { entities };
+};
+const loadClientBindingsIr = async (ctx) => {
+  requireSelfSchema(ctx.settings);
+  const ir = projectClientBindings(await loadRoutesApi(ctx));
+  const casing = createCasing(ctx.settings);
+  return {
+    entities: ir.entities.map((entity) => {
+      const originalEntity = entity.fileBase;
+      const fileBase = casing.fileBase(originalEntity);
+      const methods = entity.methods.map((method) => ({
+        ...method,
+        pascalName: casing.convertTypes(method.methodName),
+        hookName: casing.hookName(originalEntity, method.methodName)
+      }));
+      return {
+        ...entity,
+        fileBase,
+        clientName: casing.clientName(originalEntity),
+        queryOptionsName: casing.clientQueryOptionsName(originalEntity),
+        mutationOptionsName: casing.clientMutationOptionsName(originalEntity),
+        pascalEntity: casing.convertTypes(originalEntity),
+        methods,
+        queries: methods.filter((method) => method.isQuery),
+        mutations: methods.filter((method) => !method.isQuery)
+      };
+    })
+  };
+};
+export {
+  clientBindingsSchema,
+  loadClientBindingsIr,
+  projectClientBindings,
+  requireSelfSchema
+};

package/node_modules/@deterministic-code/typescript-generators/dist/common/default-casing.js

@@ -0,0 +1,53 @@
+import {
+  createCasingStrategy
+} from "@deterministic-code/generators-common/casing-strategy";
+const GENERATOR_LANGUAGE = "typescript";
+const IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const VARIANT_PREFIXES = ["update_", "create_"];
+const jsIdent = (name) => IDENT_RE.test(name) ? name : JSON.stringify(name);
+const featureEntity = (entity) => {
+  const prefix = VARIANT_PREFIXES.find((p) => entity.startsWith(p));
+  return prefix === void 0 ? entity : entity.slice(prefix.length);
+};
+const createCasing = (settings) => {
+  const casing = createCasingStrategy(GENERATOR_LANGUAGE, settings);
+  const fileBase = (stem) => casing.convertFileName(stem);
+  const directory = (entity) => casing.convertDirectories(featureEntity(entity));
+  const filePath = (stem) => `${fileBase(stem)}.ts`;
+  const convertFields = (text) => casing.convertFields(text);
+  const fieldIdent = (field) => jsIdent(convertFields(field));
+  return {
+    convertFileName: (text) => casing.convertFileName(text),
+    convertTypes: (text) => casing.convertTypes(text),
+    convertFields,
+    convertDirectories: (text) => casing.convertDirectories(text),
+    fileBase,
+    directory,
+    filePath,
+    fieldIdent,
+    serviceClassName: (entity) => casing.convertTypes(`${entity}_service`),
+    serviceInterfaceName: (entity) => casing.convertTypes(`i_${entity}_service`),
+    authoredInterfaceName: (name) => casing.convertTypes(`i_${name}`),
+    baseTypeName: (entity) => casing.convertTypes(`${entity}_base`),
+    schemaName: (name) => casing.convertTypes(`${name}_schema`),
+    validatedTypeName: (name) => casing.convertTypes(`${name}_validated`),
+    routerFnName: (entity) => casing.convertTypes(`${entity}_router`),
+    hookName: (entity, method) => casing.convertTypes(`use_${entity}_${method}`),
+    finderMethod: (field) => convertFields(`find_by_${field}`),
+    clientName: (entity) => casing.convertTypes(`${entity}_client`),
+    clientQueryOptionsName: (entity) => casing.convertTypes(`${entity}_client_query_options`),
+    clientMutationOptionsName: (entity) => casing.convertTypes(`${entity}_client_mutation_options`),
+    appFnName: () => casing.convertTypes("create_backend_app"),
+    appComponentName: () => casing.convertTypes("app"),
+    homeComponentName: () => casing.convertTypes("home"),
+    rootLayoutName: () => casing.convertTypes("root_layout"),
+    appConfigName: () => casing.convertTypes("app_config")
+  };
+};
+const defaultCasing = (settings) => createCasing(settings);
+export {
+  GENERATOR_LANGUAGE,
+  createCasing,
+  defaultCasing,
+  jsIdent
+};

package/node_modules/@deterministic-code/typescript-generators/dist/common/dictionary-candidate.js

@@ -0,0 +1,4 @@
+const isDictionaryCandidate = (candidate) => candidate.inherits === "dictionary";
+export {
+  isDictionaryCandidate
+};