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

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

@@ -0,0 +1,222 @@
+type CaseFormat = "Camel" | "Pascal" | "Snake" | "Kebab" | "Auto";
+
+type ResolvedCaseFormat = Exclude<CaseFormat, "Auto">;
+
+type LanguageCasingDefaults = {
+  file_names: ResolvedCaseFormat;
+  types: ResolvedCaseFormat;
+  fields: ResolvedCaseFormat;
+  directories: ResolvedCaseFormat;
+};
+
+export type ICasingStrategy = {
+  convertFileName: (text: string) => string;
+  convertTypes: (text: string) => string;
+  convertFields: (text: string) => string;
+  convertDirectories: (text: string) => string;
+};
+
+const CASE_FORMATS: readonly CaseFormat[] = [
+  "Camel",
+  "Pascal",
+  "Snake",
+  "Kebab",
+  "Auto",
+];
+
+/** Auto defaults from the Default Casings table. Directories follow file names. */
+const LANGUAGE_CASING_DEFAULTS = {
+  typescript: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Snake",
+    directories: "Camel",
+  },
+  javascript: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Camel",
+    directories: "Camel",
+  },
+  csharp: {
+    file_names: "Pascal",
+    types: "Pascal",
+    fields: "Pascal",
+    directories: "Pascal",
+  },
+  java: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Camel",
+    directories: "Camel",
+  },
+  python: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Snake",
+    directories: "Camel",
+  },
+  rust: {
+    file_names: "Camel",
+    types: "Pascal",
+    fields: "Snake",
+    directories: "Camel",
+  },
+  sql: {
+    file_names: "Snake",
+    types: "Snake",
+    fields: "Snake",
+    directories: "Snake",
+  },
+  openapi: {
+    file_names: "Kebab",
+    types: "Pascal",
+    fields: "Camel",
+    directories: "Kebab",
+  },
+} as const satisfies Record<string, LanguageCasingDefaults>;
+
+type CasingLanguage = keyof typeof LANGUAGE_CASING_DEFAULTS;
+
+const LANGUAGE_ALIASES: Record<string, CasingLanguage> = {
+  ts: "typescript",
+  typescript: "typescript",
+  js: "javascript",
+  javascript: "javascript",
+  py: "python",
+  python: "python",
+  cs: "csharp",
+  csharp: "csharp",
+  "c#": "csharp",
+  java: "java",
+  rs: "rust",
+  rust: "rust",
+  sql: "sql",
+  openapi: "openapi",
+};
+
+const PARSE_CASE: Record<string, CaseFormat> = {
+  camel: "Camel",
+  pascal: "Pascal",
+  snake: "Snake",
+  kebab: "Kebab",
+  auto: "Auto",
+};
+
+const wordsOf = (name: string): string[] =>
+  name
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+    .replace(/[_\-.]+/g, " ")
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.toLowerCase());
+
+const cap = (word: string): string =>
+  word.length === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1);
+
+const toCase = (name: string, format: ResolvedCaseFormat): string => {
+  const words = wordsOf(name);
+  if (words.length === 0) return name;
+  switch (format) {
+    case "Camel":
+      return words.map((w, i) => (i === 0 ? w : cap(w))).join("");
+    case "Pascal":
+      return words.map(cap).join("");
+    case "Snake":
+      return words.join("_");
+    case "Kebab":
+      return words.join("-");
+  }
+};
+
+const parseCaseFormat = (raw: string | undefined, path: string): CaseFormat => {
+  if (raw === undefined || raw === "") return "Auto";
+  const parsed = PARSE_CASE[raw.toLowerCase()];
+  if (parsed === undefined) {
+    throw new Error(
+      `${path} must be one of [${CASE_FORMATS.join(", ")}] (got "${raw}").`,
+    );
+  }
+  return parsed;
+};
+
+const resolveCasingLanguage = (language: string): CasingLanguage => {
+  const key = language.toLowerCase().replace(/[\s_]/g, "");
+  const resolved =
+    LANGUAGE_ALIASES[key] ?? LANGUAGE_ALIASES[language.toLowerCase()];
+  if (resolved === undefined || !(resolved in LANGUAGE_CASING_DEFAULTS)) {
+    throw new Error(
+      `createCasingStrategy: unknown language "${language}". Valid: ${Object.keys(LANGUAGE_CASING_DEFAULTS).join(", ")}.`,
+    );
+  }
+  return resolved as CasingLanguage;
+};
+
+const resolveLeaf = (
+  override: CaseFormat,
+  fallback: ResolvedCaseFormat,
+): ResolvedCaseFormat => (override === "Auto" ? fallback : override);
+
+class CasingStrategy implements ICasingStrategy {
+  #fileNames: ResolvedCaseFormat;
+  #types: ResolvedCaseFormat;
+  #fields: ResolvedCaseFormat;
+  #directories: ResolvedCaseFormat;
+
+  constructor(resolved: LanguageCasingDefaults) {
+    this.#fileNames = resolved.file_names;
+    this.#types = resolved.types;
+    this.#fields = resolved.fields;
+    this.#directories = resolved.directories;
+  }
+
+  convertFileName(text: string): string {
+    return toCase(text, this.#fileNames);
+  }
+
+  convertTypes(text: string): string {
+    return toCase(text, this.#types);
+  }
+
+  convertFields(text: string): string {
+    return toCase(text, this.#fields);
+  }
+
+  convertDirectories(text: string): string {
+    return toCase(text, this.#directories);
+  }
+}
+
+export type CasingStrategyOptions = {
+  prefix?: string;
+};
+
+export const createCasingStrategy = (
+  language: string,
+  settings: Record<string, string> = {},
+  options?: CasingStrategyOptions,
+): ICasingStrategy => {
+  const lang = resolveCasingLanguage(language);
+  const defaults = LANGUAGE_CASING_DEFAULTS[lang];
+  const prefix = options?.prefix ?? `languages.${lang}.casing`;
+  return new CasingStrategy({
+    file_names: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.file_names`], `${prefix}.file_names`),
+      defaults.file_names,
+    ),
+    types: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.types`], `${prefix}.types`),
+      defaults.types,
+    ),
+    fields: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.fields`], `${prefix}.fields`),
+      defaults.fields,
+    ),
+    directories: resolveLeaf(
+      parseCaseFormat(settings[`${prefix}.directories`], `${prefix}.directories`),
+      defaults.directories,
+    ),
+  });
+};

package/node_modules/@deterministic-code/generators-common/src/datasource-naming.test.ts

@@ -0,0 +1,232 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createDatasourceNaming } from "./datasource-naming.ts";
+
+type Format = "Camel" | "Pascal" | "Snake" | "Kebab";
+type Pluralize = "on" | "off";
+
+const FORMATS: readonly Format[] = ["Camel", "Pascal", "Snake", "Kebab"];
+const PLURALIZE: readonly Pluralize[] = ["on", "off"];
+
+const ENTITY = "notification_type";
+const FIELD = "channel_name";
+
+const settingsFor = (
+  leaf: "types" | "fields",
+  format: Format,
+  pluralize: Pluralize = "on",
+): Record<string, string> => ({
+  [`datasource.casing.${leaf}`]: format,
+  ...(pluralize === "off"
+    ? { "datasource.pluralize_datatable_names": "false" }
+    : {}),
+});
+
+const TYPES = {
+  tableName: {
+    on: {
+      Camel: "notificationTypes",
+      Pascal: "NotificationTypes",
+      Snake: "notification_types",
+      Kebab: "notification-types",
+    },
+    off: {
+      Camel: "notificationType",
+      Pascal: "NotificationType",
+      Snake: "notification_type",
+      Kebab: "notification-type",
+    },
+  },
+  userTable: {
+    on: {
+      Camel: "users",
+      Pascal: "Users",
+      Snake: "users",
+      Kebab: "users",
+    },
+    off: {
+      Camel: "user",
+      Pascal: "User",
+      Snake: "user",
+      Kebab: "user",
+    },
+  },
+} as const;
+
+const FIELDS = {
+  channel_name: {
+    Camel: "channelName",
+    Pascal: "ChannelName",
+    Snake: "channel_name",
+    Kebab: "channel-name",
+  },
+  role_id: {
+    Camel: "roleId",
+    Pascal: "RoleId",
+    Snake: "role_id",
+    Kebab: "role-id",
+  },
+} as const;
+
+describe("createDatasourceNaming Auto defaults", () => {
+  it("uses SQL Snake defaults and last-token pluralize", () => {
+    const naming = createDatasourceNaming({});
+    assert.equal(naming.resolveTable(ENTITY), "notification_types");
+    assert.equal(naming.resolveTable("user"), "users");
+    assert.equal(naming.columnName(FIELD), "channel_name");
+    assert.equal(naming.resolveColumn(FIELD), "channel_name");
+    assert.equal(naming.physicalStem(ENTITY), "notification_types");
+    assert.equal(naming.tableName("notification_types"), "notification_types");
+  });
+});
+
+describe("createDatasourceNaming conversion matrix", () => {
+  for (const format of FORMATS) {
+    for (const pluralize of PLURALIZE) {
+      it(`types × ${format} × pluralize ${pluralize}`, () => {
+        const naming = createDatasourceNaming(
+          settingsFor("types", format, pluralize),
+        );
+        assert.equal(
+          naming.resolveTable(ENTITY),
+          TYPES.tableName[pluralize][format],
+        );
+        assert.equal(
+          naming.resolveTable("user"),
+          TYPES.userTable[pluralize][format],
+        );
+        assert.equal(naming.columnName(FIELD), "channel_name");
+      });
+    }
+  }
+
+  for (const format of FORMATS) {
+    it(`fields × ${format}`, () => {
+      const naming = createDatasourceNaming(settingsFor("fields", format));
+      assert.equal(naming.columnName("channel_name"), FIELDS.channel_name[format]);
+      assert.equal(naming.resolveColumn("channel_name"), FIELDS.channel_name[format]);
+      assert.equal(naming.columnName("role_id"), FIELDS.role_id[format]);
+      assert.equal(naming.resolveTable(ENTITY), "notification_types");
+    });
+  }
+});
+
+describe("createDatasourceNaming overrides", () => {
+  it("treats Auto and empty as omitted", () => {
+    const omitted = createDatasourceNaming({});
+    const explicit = createDatasourceNaming({
+      "datasource.casing.types": "auto",
+      "datasource.casing.fields": "AUTO",
+    });
+    assert.equal(omitted.resolveTable(ENTITY), explicit.resolveTable(ENTITY));
+    assert.equal(omitted.columnName(FIELD), explicit.columnName(FIELD));
+  });
+
+  it("ignores languages.sql.casing keys", () => {
+    const naming = createDatasourceNaming({
+      "languages.sql.casing.types": "Pascal",
+      "languages.sql.casing.fields": "Camel",
+    });
+    assert.equal(naming.resolveTable(ENTITY), "notification_types");
+    assert.equal(naming.columnName(FIELD), "channel_name");
+  });
+
+  it("throws on an unknown case format", () => {
+    assert.throws(
+      () => createDatasourceNaming({ "datasource.casing.types": "screaming" }),
+      /datasource\.casing\.types must be one of/,
+    );
+  });
+});
+
+describe("createDatasourceNaming verbatim and mapping", () => {
+  it("treats omitted and snake stems as cased", () => {
+    const naming = createDatasourceNaming({});
+    assert.equal(naming.isVerbatim("user"), false);
+    assert.equal(naming.isVerbatim("email_address"), false);
+  });
+
+  it("treats mixed-case mappings as verbatim", () => {
+    const naming = createDatasourceNaming({});
+    assert.equal(naming.isVerbatim("OldRvwsTbl"), true);
+    assert.equal(naming.isVerbatim("UsrProfiles"), true);
+    assert.equal(naming.isVerbatim("CntID"), true);
+  });
+
+  it("resolveTable pluralizes a snake mapping", () => {
+    const naming = createDatasourceNaming({});
+    assert.equal(naming.resolveTable("users_base", "user"), "users");
+  });
+
+  it("resolveTable keeps a snake mapping singular when pluralize is off", () => {
+    const naming = createDatasourceNaming({
+      "datasource.pluralize_datatable_names": "false",
+    });
+    assert.equal(naming.resolveTable("users_base", "user"), "user");
+  });
+
+  it("resolveTable keeps a non-snake mapping verbatim", () => {
+    const naming = createDatasourceNaming({
+      "datasource.casing.types": "Pascal",
+    });
+    assert.equal(naming.resolveTable("old_reviews", "OldRvwsTbl"), "OldRvwsTbl");
+    assert.equal(naming.physicalStem("OldRvwsTbl"), "OldRvwsTbl");
+  });
+
+  it("resolveColumn applies field casing and keeps verbatim overlays", () => {
+    const naming = createDatasourceNaming({
+      "datasource.casing.fields": "Camel",
+    });
+    assert.equal(naming.resolveColumn("email", "email_address"), "emailAddress");
+    assert.equal(naming.resolveColumn("key", "CntID"), "CntID");
+    assert.equal(naming.resolveColumn("first_name"), "firstName");
+  });
+});
+
+describe("createDatasourceNaming tableName pluralize", () => {
+  it("pluralizes when the flag is true or empty", () => {
+    assert.equal(
+      createDatasourceNaming({
+        "datasource.pluralize_datatable_names": "true",
+      }).resolveTable("user"),
+      "users",
+    );
+    assert.equal(
+      createDatasourceNaming({
+        "datasource.pluralize_datatable_names": "",
+      }).resolveTable("user"),
+      "users",
+    );
+  });
+
+  it("handles irregular and already-plural names", () => {
+    const naming = createDatasourceNaming({});
+    assert.equal(naming.resolveTable("person"), "people");
+    assert.equal(naming.resolveTable("category"), "categories");
+    assert.equal(naming.resolveTable("users"), "users");
+    assert.equal(naming.resolveTable(""), "");
+    assert.equal(naming.physicalStem("backend_type"), "backend_types");
+    assert.equal(naming.physicalStem("task_step"), "task_steps");
+    assert.equal(naming.physicalStem("local_setting"), "local_settings");
+    assert.equal(naming.physicalStem("man"), "men");
+    assert.equal(naming.physicalStem("child"), "children");
+    assert.equal(naming.physicalStem("mouse"), "mice");
+    assert.equal(naming.physicalStem("candy"), "candies");
+    assert.equal(naming.physicalStem("key"), "keys");
+    assert.equal(naming.physicalStem("analytics"), "analytics");
+    assert.equal(naming.physicalStem("news"), "news");
+    assert.equal(naming.physicalStem("series"), "series");
+    assert.equal(naming.physicalStem("leaf"), "leaves");
+    assert.equal(naming.physicalStem("knife"), "knives");
+    assert.equal(naming.physicalStem(""), "");
+  });
+
+  it("leaves the stem unchanged when pluralize is off", () => {
+    const naming = createDatasourceNaming({
+      "datasource.pluralize_datatable_names": "false",
+    });
+    assert.equal(naming.physicalStem("backend"), "backend");
+    assert.equal(naming.physicalStem("backend_type"), "backend_type");
+    assert.equal(naming.resolveTable("contact"), "contact");
+  });
+});

package/node_modules/@deterministic-code/generators-common/src/datasource-naming.ts

@@ -0,0 +1,53 @@
+/// <reference path="./pluralize-module.d.ts" />
+import { createCasingStrategy } from "./casing-strategy.ts";
+import pluralize from "pluralize";
+
+const SNAKE_STEM = /^[a-z_][a-z0-9_]*$/;
+const lastTokenPluralize = (name: string): string =>
+  name ? name.replace(/[^_]+$/, (token) => pluralize(token)) : name;
+
+export type IDatasourceNaming = {
+  isVerbatim: (mapping: string) => boolean
+  physicalStem: (logicalOrMapping: string) => string
+  tableName: (stem: string) => string
+  columnName: (stem: string) => string
+  resolveTable: (logical: string, mapping?: string) => string
+  resolveColumn: (logical: string, mapping?: string) => string
+};
+
+/** Physical table/column names from `datasource.casing` + last-token pluralize. */
+export const createDatasourceNaming = (
+  settings: Record<string, string>,
+): IDatasourceNaming => {
+  const casing = createCasingStrategy("sql", settings, {
+    prefix: "datasource.casing",
+  });
+  const pluralizeNames =
+    String(settings["datasource.pluralize_datatable_names"]) !== "false";
+  const isVerbatim = (mapping: string): boolean => !SNAKE_STEM.test(mapping);
+  const tableName = (stem: string): string => casing.convertTypes(stem);
+  const columnName = (stem: string): string => casing.convertFields(stem);
+  const physicalStem = (name: string): string =>
+    isVerbatim(name)
+      ? name
+      : pluralizeNames
+        ? lastTokenPluralize(name)
+        : name;
+  const resolve = (
+    convert: (stem: string) => string,
+    logical: string,
+    mapping?: string,
+  ): string => {
+    const stem = mapping ?? logical;
+    return isVerbatim(stem) ? stem : convert(stem);
+  };
+  return {
+    isVerbatim,
+    physicalStem,
+    tableName,
+    columnName,
+    resolveTable: (logical, mapping) =>
+      resolve((stem) => tableName(physicalStem(stem)), logical, mapping),
+    resolveColumn: (logical, mapping) => resolve(columnName, logical, mapping),
+  };
+};