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

package/node_modules/@deterministic-code/generators-common/dist/spec-types.d.ts

@@ -0,0 +1,37 @@
+import type { DatasourceTable, IDeterministic, ServiceByField, Type, TypeField } from "@deterministic-code/deterministic-generators-common/parser";
+export declare const TYPES_YAML = "types.yaml";
+export declare const DATASOURCE_YAML = "datasource.yaml";
+export declare const DATASOURCE_SEEDS_YAML = "datasource_seeds.yaml";
+export declare const SERVICES_YAML = "services.yaml";
+export declare const ROUTES_YAML = "routes.yaml";
+export declare const typeHasTag: (type: Type, tag: string) => boolean;
+export declare const typesWithTag: (types: readonly Type[], tag: string) => Type[];
+export declare const datasourceTypesOf: (spec: IDeterministic) => Type[];
+export declare const isDictionaryType: (type: Type | undefined) => boolean;
+export declare const viewTypesOf: (spec: IDeterministic) => Type[];
+export declare const authoredViewTypesOf: (spec: IDeterministic) => Type[];
+export declare const isManyToMany: (type: Type) => boolean;
+export declare const isReadonlyLookup: (type: Type) => boolean;
+/** Nested eager collections (`address[]`, `settings{}`) are view relations, not persisted columns. */
+export declare const isCollectionField: (field: TypeField) => boolean;
+export declare const columnFields: (fields: readonly TypeField[]) => TypeField[];
+export declare const tableKind: (type: Type) => string;
+type TypeKey = Pick<Type, "inherits" | "fields" | "ids">;
+/** Ordered identity columns: `ids`, else `is_id`, else `is_fixed_id`, else injected `id`. */
+export declare const identityColumns: (type?: TypeKey, table?: DatasourceTable) => string[];
+export declare const primaryKeyColumn: (table: DatasourceTable | undefined, type?: TypeKey) => string;
+export declare const pkName: (type: TypeKey, table?: DatasourceTable) => string;
+export declare const isPkField: (field: TypeField, type: TypeKey, table?: DatasourceTable) => boolean;
+export declare const uniqueLookupFields: (type: TypeKey, table?: DatasourceTable) => ServiceByField[];
+export declare const tableByName: (spec: IDeterministic) => Map<string, DatasourceTable>;
+/** Walk `references` to the parent field type; collections keep `[]` / `{}`. */
+export declare const fieldTypeOf: (field: TypeField, typesByName: ReadonlyMap<string, Type>, seen?: Set<string>) => string;
+export declare const isOwnerIdentityRef: (references: TypeField["references"], selfName: string, byName: Map<string, Type>) => boolean;
+export declare const dictionaryEntryFields: (dict: Type) => {
+    key: TypeField;
+    value: TypeField;
+} | undefined;
+export declare const dictionaryOfField: (field: TypeField, byName: Map<string, Type>) => Type | undefined;
+export declare const persistedColumnFields: (type: Type, byName: Map<string, Type>) => TypeField[];
+export declare const dictionaryUniqueColumns: (type: Type, byName: Map<string, Type>) => string[];
+export {};

package/node_modules/@deterministic-code/generators-common/dist/spec-types.js

@@ -0,0 +1,162 @@
+const TYPES_YAML = "types.yaml";
+const DATASOURCE_YAML = "datasource.yaml";
+const DATASOURCE_SEEDS_YAML = "datasource_seeds.yaml";
+const SERVICES_YAML = "services.yaml";
+const ROUTES_YAML = "routes.yaml";
+const typeHasTag = (type, tag) => type.tags.includes(tag);
+const typesWithTag = (types, tag) => types.filter((type) => typeHasTag(type, tag));
+const datasourceTypesOf = (spec) => typesWithTag(spec.expandedTypes, "datasource_type");
+const isDictionaryType = (type) => type?.inherits === "dictionary";
+const viewTypesOf = (spec) => typesWithTag(spec.expandedTypes, "view_type").filter(
+  (type) => !isDictionaryType(type)
+);
+const authoredViewTypesOf = (spec) => typesWithTag(spec.types, "view_type").filter((type) => !isDictionaryType(type));
+const isManyToMany = (type) => typeHasTag(type, "many_to_many");
+const isReadonlyLookup = (type) => typeHasTag(type, "readonly_lookup");
+const isCollectionField = (field) => field.kind === "type" && (field.isArray || field.isMap === true);
+const columnFields = (fields) => fields.filter((field) => !isCollectionField(field));
+const tableKind = (type) => {
+  if (isManyToMany(type)) return "many-to-many";
+  if (isReadonlyLookup(type)) return "readonly-lookup";
+  return "standard";
+};
+const markedIds = (type) => type.fields.filter((f) => f.isId === true).map((f) => f.name);
+const identityColumns = (type, table) => {
+  if (type?.ids !== void 0 && type.ids.length > 0) return [...type.ids];
+  const marked = type !== void 0 ? markedIds(type) : [];
+  if (marked.length > 0) return marked;
+  const fixed = table?.fields.find((f) => f.isFixedId);
+  if (fixed) return [fixed.name];
+  if (type?.inherits === "set" || type === void 0) return ["id"];
+  return [];
+};
+const primaryKeyColumn = (table, type) => identityColumns(type, table)[0] ?? "id";
+const pkName = (type, table) => primaryKeyColumn(table, type);
+const isPkField = (field, type, table) => identityColumns(type, table).includes(field.name);
+const uniqueLookupFields = (type, table) => {
+  const out = [];
+  const add = (name) => {
+    if (out.some((e) => e.field === name)) return;
+    const f = type.fields.find((x) => x.name === name);
+    if (f !== void 0 && isCollectionField(f)) return;
+    out.push({
+      field: name,
+      type: typeof f?.type === "string" ? f.type : "string",
+      ...typeof f?.size === "number" ? { size: f.size } : {}
+    });
+  };
+  for (const name of identityColumns(type, table)) add(name);
+  for (const overlay of table?.fields ?? []) {
+    if (overlay.isUnique) add(overlay.name);
+  }
+  for (const name of table?.uniqueIndexFields ?? []) add(name);
+  return out;
+};
+const tableByName = (spec) => new Map(spec.datasource.map((table) => [table.name, table]));
+const referenceTarget = (references) => {
+  if (Array.isArray(references)) return [references[0], references[1]];
+  const [table, col] = references.split(".");
+  return [table ?? "", col ?? ""];
+};
+const fieldTypeOf = (field, typesByName, seen = /* @__PURE__ */ new Set()) => {
+  if (field.type.endsWith("[]") || field.type.endsWith("{}")) {
+    return field.type;
+  }
+  if (field.references !== void 0) {
+    const [logicalTable, logicalCol] = referenceTarget(field.references);
+    const key = `${logicalTable}.${logicalCol}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      const parent = typesByName.get(logicalTable)?.fields.find((item) => item.name === logicalCol);
+      if (parent !== void 0) return fieldTypeOf(parent, typesByName, seen);
+    }
+  }
+  return field.type || "string";
+};
+const splitDot = (value) => {
+  const i = value.indexOf(".");
+  return i === -1 ? void 0 : [value.slice(0, i), value.slice(i + 1)];
+};
+const identityNamesOf = (type, byName, stack = /* @__PURE__ */ new Set()) => {
+  if (!type) return /* @__PURE__ */ new Set();
+  if (stack.has(type.name)) return /* @__PURE__ */ new Set();
+  const local = identityColumns(type);
+  if (local.length > 0) return new Set(local);
+  if (type.inherits && type.inherits !== "dictionary") {
+    stack.add(type.name);
+    return identityNamesOf(byName.get(type.inherits), byName, stack);
+  }
+  return /* @__PURE__ */ new Set();
+};
+const isOwnerIdentityRef = (references, selfName, byName) => {
+  if (references === void 0) return false;
+  const parts = (Array.isArray(references) ? references : [references]).map(
+    (ref) => {
+      const split = splitDot(ref);
+      return split ? { type: split[0], field: split[1] } : { type: "", field: ref };
+    }
+  );
+  const owner = parts[0].type;
+  if (!owner || owner === selfName) return false;
+  const identity = identityNamesOf(byName.get(owner), byName);
+  return parts.every((p) => p.type === owner && identity.has(p.field));
+};
+const dictionaryEntryFields = (dict) => {
+  const key = dict.fields.find((f) => f.name === "key");
+  const value = dict.fields.find((f) => f.name === "value");
+  if (key === void 0 || value === void 0) return void 0;
+  return { key, value };
+};
+const dictionaryOfField = (field, byName) => {
+  if (field.isMap !== true) return void 0;
+  const dict = byName.get(field.base);
+  return isDictionaryType(dict) ? dict : void 0;
+};
+const persistedColumnFields = (type, byName) => {
+  if (!isDictionaryType(type)) return columnFields(type.fields);
+  const value = type.fields.find((f) => f.name === "value");
+  if (value === void 0 || value.kind !== "type" || value.isArray || value.isMap === true) {
+    return columnFields(type.fields);
+  }
+  const nested = byName.get(value.base);
+  if (nested === void 0) return columnFields(type.fields);
+  return [
+    ...columnFields(type.fields.filter((f) => f.name !== "value")),
+    ...columnFields(nested.fields)
+  ];
+};
+const dictionaryUniqueColumns = (type, byName) => {
+  if (!isDictionaryType(type)) return [];
+  const owners = type.fields.filter((f) => isOwnerIdentityRef(f.references, type.name, byName)).map((f) => f.name);
+  return type.fields.some((f) => f.name === "key") ? [...owners, "key"] : owners;
+};
+export {
+  DATASOURCE_SEEDS_YAML,
+  DATASOURCE_YAML,
+  ROUTES_YAML,
+  SERVICES_YAML,
+  TYPES_YAML,
+  authoredViewTypesOf,
+  columnFields,
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  dictionaryUniqueColumns,
+  fieldTypeOf,
+  identityColumns,
+  isCollectionField,
+  isDictionaryType,
+  isManyToMany,
+  isOwnerIdentityRef,
+  isPkField,
+  isReadonlyLookup,
+  persistedColumnFields,
+  pkName,
+  primaryKeyColumn,
+  tableByName,
+  tableKind,
+  typeHasTag,
+  typesWithTag,
+  uniqueLookupFields,
+  viewTypesOf
+};

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

@@ -0,0 +1,95 @@
+{
+  "name": "@deterministic-code/generators-common",
+  "version": "0.0.1",
+  "description": "Shared generator helpers: reader, entries, routes-api, and template fill.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deterministic-code/generators-common.git"
+  },
+  "type": "module",
+  "imports": {
+    "#mustache": {
+      "types": "./src/mustache-module.d.ts",
+      "default": "mustache"
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./deterministic-default-value-converter": {
+      "types": "./dist/deterministic-default-value-converter.d.js",
+      "import": "./dist/deterministic-default-value-converter.js"
+    },
+    "./deterministic-type-converter": {
+      "types": "./dist/deterministic-type-converter.d.js",
+      "import": "./dist/deterministic-type-converter.js"
+    },
+    "./casing-strategy": {
+      "types": "./dist/casing-strategy.d.js",
+      "import": "./dist/casing-strategy.js"
+    },
+    "./datasource-naming": {
+      "types": "./dist/datasource-naming.d.js",
+      "import": "./dist/datasource-naming.js"
+    },
+    "./datasource-type-tree": {
+      "types": "./dist/datasource-type-tree.d.js",
+      "import": "./dist/datasource-type-tree.js"
+    },
+    "./default-token": {
+      "types": "./dist/default-token.d.js",
+      "import": "./dist/default-token.js"
+    },
+    "./deterministic-reader": {
+      "types": "./dist/deterministic-reader.d.js",
+      "import": "./dist/deterministic-reader.js"
+    },
+    "./fill": {
+      "types": "./dist/fill.d.js",
+      "import": "./dist/fill.js"
+    },
+    "./generate-context": {
+      "types": "./dist/generate-context.d.js",
+      "import": "./dist/generate-context.js"
+    },
+    "./generate-entry": {
+      "types": "./dist/generate-entry.d.js",
+      "import": "./dist/generate-entry.js"
+    },
+    "./import-generator": {
+      "types": "./dist/import-generator.d.js",
+      "import": "./dist/import-generator.js"
+    },
+    "./reference-verifier": {
+      "types": "./dist/reference-verifier.d.js",
+      "import": "./dist/reference-verifier.js"
+    },
+    "./routes-api": {
+      "types": "./dist/routes-api.d.js",
+      "import": "./dist/routes-api.js"
+    },
+    "./routes-api-converter": {
+      "types": "./dist/routes-api-converter.d.js",
+      "import": "./dist/routes-api-converter.js"
+    },
+    "./settings": {
+      "types": "./dist/settings.d.js",
+      "import": "./dist/settings.js"
+    },
+    "./spec-types": {
+      "types": "./dist/spec-types.d.js",
+      "import": "./dist/spec-types.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "tsconfig.build.json"
+  ],
+  "dependencies": {
+    "@deterministic-code/deterministic-generators-common": "0.1.0",
+    "@types/pluralize": "^0.0.33",
+    "mustache": "^4.2.0",
+    "pluralize": "^8.0.0",
+    "yaml": "^2.6.0"
+  }
+}

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

@@ -0,0 +1,404 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  createCasingStrategy,
+  type ICasingStrategy,
+} from "./casing-strategy.ts";
+
+type ResolvedFormat = "Camel" | "Pascal" | "Snake" | "Kebab";
+type Leaf = "file_names" | "types" | "fields" | "directories";
+
+const FORMATS: readonly ResolvedFormat[] = [
+  "Camel",
+  "Pascal",
+  "Snake",
+  "Kebab",
+];
+
+const LEAVES: readonly Leaf[] = [
+  "file_names",
+  "types",
+  "fields",
+  "directories",
+];
+
+const convert = (
+  casing: ICasingStrategy,
+  leaf: Leaf,
+  text: string,
+): string => {
+  switch (leaf) {
+    case "file_names":
+      return casing.convertFileName(text);
+    case "types":
+      return casing.convertTypes(text);
+    case "fields":
+      return casing.convertFields(text);
+    case "directories":
+      return casing.convertDirectories(text);
+  }
+};
+
+const EXPECTED: Record<string, Record<ResolvedFormat, string>> = {
+  notification_type: {
+    Camel: "notificationType",
+    Pascal: "NotificationType",
+    Snake: "notification_type",
+    Kebab: "notification-type",
+  },
+  "notification-type": {
+    Camel: "notificationType",
+    Pascal: "NotificationType",
+    Snake: "notification_type",
+    Kebab: "notification-type",
+  },
+  notificationType: {
+    Camel: "notificationType",
+    Pascal: "NotificationType",
+    Snake: "notification_type",
+    Kebab: "notification-type",
+  },
+  NotificationType: {
+    Camel: "notificationType",
+    Pascal: "NotificationType",
+    Snake: "notification_type",
+    Kebab: "notification-type",
+  },
+  role_id: {
+    Camel: "roleId",
+    Pascal: "RoleId",
+    Snake: "role_id",
+    Kebab: "role-id",
+  },
+  xml_http_request: {
+    Camel: "xmlHttpRequest",
+    Pascal: "XmlHttpRequest",
+    Snake: "xml_http_request",
+    Kebab: "xml-http-request",
+  },
+  HTTPResponse: {
+    Camel: "httpResponse",
+    Pascal: "HttpResponse",
+    Snake: "http_response",
+    Kebab: "http-response",
+  },
+  user: {
+    Camel: "user",
+    Pascal: "User",
+    Snake: "user",
+    Kebab: "user",
+  },
+  a: {
+    Camel: "a",
+    Pascal: "A",
+    Snake: "a",
+    Kebab: "a",
+  },
+};
+
+describe("createCasingStrategy conversion matrix", () => {
+  for (const input of Object.keys(EXPECTED)) {
+    for (const format of FORMATS) {
+      for (const leaf of LEAVES) {
+        it(`${JSON.stringify(input)} × ${format} × ${leaf}`, () => {
+          const casing = createCasingStrategy("typescript", {
+            [`languages.typescript.casing.${leaf}`]: format,
+          });
+          assert.equal(convert(casing, leaf, input), EXPECTED[input]![format]);
+        });
+      }
+    }
+  }
+
+  it('returns "" unchanged for every format and leaf', () => {
+    for (const format of FORMATS) {
+      for (const leaf of LEAVES) {
+        const casing = createCasingStrategy("typescript", {
+          [`languages.typescript.casing.${leaf}`]: format,
+        });
+        assert.equal(convert(casing, leaf, ""), "");
+      }
+    }
+  });
+
+  it('returns "   " unchanged for every format and leaf', () => {
+    for (const format of FORMATS) {
+      for (const leaf of LEAVES) {
+        const casing = createCasingStrategy("typescript", {
+          [`languages.typescript.casing.${leaf}`]: format,
+        });
+        assert.equal(convert(casing, leaf, "   "), "   ");
+      }
+    }
+  });
+});
+
+describe("createCasingStrategy Auto defaults", () => {
+  const samples: Array<{
+    language: string;
+    file: string;
+    type: string;
+    field: string;
+    directory: string;
+  }> = [
+    {
+      language: "typescript",
+      file: "notificationType",
+      type: "NotificationType",
+      field: "notification_type",
+      directory: "notificationType",
+    },
+    {
+      language: "javascript",
+      file: "notificationType",
+      type: "NotificationType",
+      field: "notificationType",
+      directory: "notificationType",
+    },
+    {
+      language: "csharp",
+      file: "NotificationType",
+      type: "NotificationType",
+      field: "NotificationType",
+      directory: "NotificationType",
+    },
+    {
+      language: "java",
+      file: "notificationType",
+      type: "NotificationType",
+      field: "notificationType",
+      directory: "notificationType",
+    },
+    {
+      language: "python",
+      file: "notificationType",
+      type: "NotificationType",
+      field: "notification_type",
+      directory: "notificationType",
+    },
+    {
+      language: "rust",
+      file: "notificationType",
+      type: "NotificationType",
+      field: "notification_type",
+      directory: "notificationType",
+    },
+    {
+      language: "sql",
+      file: "notification_type",
+      type: "notification_type",
+      field: "notification_type",
+      directory: "notification_type",
+    },
+    {
+      language: "openapi",
+      file: "notification-type",
+      type: "NotificationType",
+      field: "notificationType",
+      directory: "notification-type",
+    },
+  ];
+
+  for (const sample of samples) {
+    it(`uses Default Casings for ${sample.language} when overrides are omitted`, () => {
+      const casing = createCasingStrategy(sample.language);
+      assert.equal(casing.convertFileName("notification_type"), sample.file);
+      assert.equal(casing.convertTypes("notification_type"), sample.type);
+      assert.equal(casing.convertFields("notification_type"), sample.field);
+      assert.equal(
+        casing.convertDirectories("notification_type"),
+        sample.directory,
+      );
+    });
+  }
+
+  it("treats Auto the same as an omitted override", () => {
+    const omitted = createCasingStrategy("typescript");
+    const explicit = createCasingStrategy("typescript", {
+      "languages.typescript.casing.file_names": "Auto",
+      "languages.typescript.casing.types": "auto",
+      "languages.typescript.casing.fields": "AUTO",
+      "languages.typescript.casing.directories": "Auto",
+    });
+    assert.equal(
+      omitted.convertFileName("project_setting"),
+      explicit.convertFileName("project_setting"),
+    );
+    assert.equal(
+      omitted.convertTypes("project_setting"),
+      explicit.convertTypes("project_setting"),
+    );
+    assert.equal(
+      omitted.convertFields("project_setting"),
+      explicit.convertFields("project_setting"),
+    );
+    assert.equal(
+      omitted.convertDirectories("project_setting"),
+      explicit.convertDirectories("project_setting"),
+    );
+  });
+
+  it("treats an empty settings value as Auto", () => {
+    const omitted = createCasingStrategy("typescript");
+    const blank = createCasingStrategy("typescript", {
+      "languages.typescript.casing.file_names": "",
+      "languages.typescript.casing.types": "",
+      "languages.typescript.casing.fields": "",
+      "languages.typescript.casing.directories": "",
+    });
+    assert.equal(
+      omitted.convertFileName("role_id"),
+      blank.convertFileName("role_id"),
+    );
+    assert.equal(omitted.convertTypes("role_id"), blank.convertTypes("role_id"));
+    assert.equal(
+      omitted.convertFields("role_id"),
+      blank.convertFields("role_id"),
+    );
+    assert.equal(
+      omitted.convertDirectories("role_id"),
+      blank.convertDirectories("role_id"),
+    );
+  });
+
+  it("resolves language aliases", () => {
+    assert.equal(
+      createCasingStrategy("ts").convertFields("role_id"),
+      createCasingStrategy("typescript").convertFields("role_id"),
+    );
+    assert.equal(
+      createCasingStrategy("TypeScript").convertFields("role_id"),
+      createCasingStrategy("typescript").convertFields("role_id"),
+    );
+    assert.equal(
+      createCasingStrategy("js").convertFields("role_id"),
+      createCasingStrategy("javascript").convertFields("role_id"),
+    );
+    assert.equal(
+      createCasingStrategy("py").convertFields("role_id"),
+      createCasingStrategy("python").convertFields("role_id"),
+    );
+    assert.equal(createCasingStrategy("C#").convertFields("role_id"), "RoleId");
+    assert.equal(createCasingStrategy("cs").convertFields("role_id"), "RoleId");
+    assert.equal(
+      createCasingStrategy("c_sharp").convertFields("role_id"),
+      "RoleId",
+    );
+    assert.equal(
+      createCasingStrategy("rs").convertFileName("user_service"),
+      "userService",
+    );
+  });
+});
+
+describe("createCasingStrategy overrides", () => {
+  it("applies per-leaf overrides without changing the others", () => {
+    const casing = createCasingStrategy("typescript", {
+      "languages.typescript.casing.file_names": "Pascal",
+      "languages.typescript.casing.fields": "Camel",
+    });
+    assert.equal(casing.convertFileName("notification_type"), "NotificationType");
+    assert.equal(casing.convertTypes("notification_type"), "NotificationType");
+    assert.equal(casing.convertFields("notification_type"), "notificationType");
+    assert.equal(
+      casing.convertDirectories("notification_type"),
+      "notificationType",
+    );
+  });
+
+  it("accepts snake, kebab, pascal, and camel overrides", () => {
+    const casing = createCasingStrategy("rust", {
+      "languages.rust.casing.file_names": "Snake",
+      "languages.rust.casing.types": "Kebab",
+      "languages.rust.casing.fields": "Pascal",
+      "languages.rust.casing.directories": "Camel",
+    });
+    assert.equal(
+      casing.convertFileName("NotificationType"),
+      "notification_type",
+    );
+    assert.equal(casing.convertTypes("notification_type"), "notification-type");
+    assert.equal(casing.convertFields("notification_type"), "NotificationType");
+    assert.equal(
+      casing.convertDirectories("notification_type"),
+      "notificationType",
+    );
+  });
+
+  it("reads dotted settings keys", () => {
+    const settings = {
+      "languages.typescript.casing.file_names": "Kebab",
+      "languages.typescript.casing.types": "Snake",
+      "languages.typescript.casing.fields": "Pascal",
+      "languages.typescript.casing.directories": "Pascal",
+    };
+    const casing = createCasingStrategy("typescript", settings);
+    assert.equal(casing.convertFileName("user_summary"), "user-summary");
+    assert.equal(casing.convertTypes("user_summary"), "user_summary");
+    assert.equal(casing.convertFields("user_summary"), "UserSummary");
+    assert.equal(casing.convertDirectories("user_summary"), "UserSummary");
+  });
+
+  it("throws on an unknown language", () => {
+    assert.throws(
+      () => createCasingStrategy("cobol"),
+      /unknown language "cobol"/,
+    );
+  });
+
+  for (const leaf of LEAVES) {
+    it(`throws on an unknown case format for ${leaf}`, () => {
+      assert.throws(
+        () =>
+          createCasingStrategy("typescript", {
+            [`languages.typescript.casing.${leaf}`]: "screaming",
+          }),
+        new RegExp(`${leaf} must be one of`),
+      );
+    });
+  }
+});
+
+describe("createCasingStrategy prefix", () => {
+  it("reads datasource.casing keys with SQL Snake Auto defaults", () => {
+    const casing = createCasingStrategy(
+      "sql",
+      {
+        "datasource.casing.types": "Pascal",
+        "datasource.casing.fields": "Camel",
+      },
+      { prefix: "datasource.casing" },
+    );
+    assert.equal(casing.convertTypes("notification_type"), "NotificationType");
+    assert.equal(casing.convertFields("channel_name"), "channelName");
+    assert.equal(casing.convertFileName("notification_type"), "notification_type");
+    assert.equal(
+      casing.convertDirectories("notification_type"),
+      "notification_type",
+    );
+  });
+
+  it("throws with the custom prefix in the error path", () => {
+    assert.throws(
+      () =>
+        createCasingStrategy(
+          "sql",
+          { "datasource.casing.types": "screaming" },
+          { prefix: "datasource.casing" },
+        ),
+      /datasource\.casing\.types must be one of/,
+    );
+  });
+
+  it("ignores languages.sql.casing when a custom prefix is set", () => {
+    const casing = createCasingStrategy(
+      "sql",
+      {
+        "languages.sql.casing.types": "Pascal",
+        "datasource.casing.types": "Kebab",
+      },
+      { prefix: "datasource.casing" },
+    );
+    assert.equal(casing.convertTypes("notification_type"), "notification-type");
+  });
+});