@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/converters/PluralizerConverter.ts

@@ -0,0 +1,67 @@
+const uncountable = new Set(["sheep", "fish", "series", "species", "deer", "news"]);
+const irregular: Record<string, string> = {
+  person: "people",
+  child: "children",
+  man: "men",
+  woman: "women",
+  mouse: "mice",
+  goose: "geese",
+  tooth: "teeth",
+  foot: "feet",
+  ox: "oxen",
+};
+const irregularSingular = Object.fromEntries(
+  Object.entries(irregular).map(([singular, plural]) => [plural, singular]),
+);
+
+const vowel = (c: string) => "aeiou".includes(c);
+const consonant = (c: string) => /[a-z]/.test(c) && !vowel(c);
+const yies = (word: string) => word.length >= 4 && word.endsWith("ies") && consonant(word[word.length - 4]);
+const consonantY = (word: string) => word.length >= 2 && word.endsWith("y") && consonant(word[word.length - 2]);
+const sibilant = (word: string) =>
+  word.endsWith("ch") ||
+  word.endsWith("sh") ||
+  word.endsWith("x") ||
+  word.endsWith("z") ||
+  word.endsWith("ss") ||
+  (word.length >= 2 && word.endsWith("s") && !word.endsWith("es") && vowel(word[word.length - 2]));
+const sibilantEs = (word: string) => word.length > 2 && word.endsWith("es") && sibilant(word.slice(0, -2));
+
+const restore = (original: string, result: string) =>
+  original[0] === original[0].toUpperCase()
+    ? result[0].toUpperCase() + result.slice(1)
+    : result;
+
+const plural = (word: string) =>
+  uncountable.has(word) || word in irregularSingular
+    ? word
+    : irregular[word] ??
+      (yies(word) || sibilantEs(word)
+        ? word
+        : sibilant(word)
+          ? word + "es"
+          : consonantY(word)
+            ? word.slice(0, -1) + "ies"
+            : word.endsWith("s")
+              ? word
+              : word + "s");
+
+const singular = (word: string) =>
+  uncountable.has(word) || word in irregular
+    ? word
+    : (irregularSingular[word] ??
+      (yies(word)
+        ? word.slice(0, -3) + "y"
+        : sibilantEs(word)
+          ? word.slice(0, -2)
+          : word.endsWith("s") && !sibilant(word)
+            ? word.slice(0, -1)
+            : word));
+
+const apply = (word: string, transform: (word: string) => string) =>
+  word.length === 0 ? word : restore(word, transform(word.toLowerCase()));
+
+export class PluralizerConverter {
+  convert = (from: string) => apply(from, plural);
+  reverseConvert = (to: string) => apply(to, singular);
+}

package/src/converters/RegexConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { RegexConverter } from "./RegexConverter.ts";
+
+describe("RegexConverter", () => {
+  it("replaces with regex", () => {
+    expect(new RegexConverter(/\d+/g, "").convert("Ada 1 Lovelace")).toBe("Ada  Lovelace");
+    expect(new RegexConverter("\\d+", "").convert("Ada 1 Lovelace")).toBe("Ada  Lovelace");
+    expect(new RegexConverter(/id_(\d+)/, "id-$1").convert("id_7")).toBe("id-7");
+    expect(new RegexConverter(/id_(\d+)/, "id-$1").reverseConvert("id_7")).toBe("id_7");
+  });
+});

package/src/converters/RegexConverter.ts

@@ -0,0 +1,14 @@
+export class RegexConverter {
+  readonly regex: RegExp;
+  readonly replacement: string;
+
+  constructor(pattern: string | RegExp, replacement: string) {
+    this.regex = typeof pattern === "string"
+      ? new RegExp(pattern, "g")
+      : new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+    this.replacement = replacement;
+  }
+
+  convert = (from: string) => from.replace(this.regex, this.replacement);
+  reverseConvert = (to: string) => to;
+}

package/src/converters/ReplaceConverter.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { ReplaceConverter } from "./ReplaceConverter.ts";
+
+describe("ReplaceConverter", () => {
+  it("replaces literals", () => {
+    expect(new ReplaceConverter("_", " ").convert("Ada_Lovelace")).toBe("Ada Lovelace");
+    expect(new ReplaceConverter("_", " ").reverseConvert("Ada Lovelace")).toBe("Ada_Lovelace");
+  });
+});

package/src/converters/ReplaceConverter.ts

@@ -0,0 +1,6 @@
+export class ReplaceConverter {
+  constructor(readonly search: string, readonly replacement: string) {}
+
+  convert = (from: string) => from.replaceAll(this.search, this.replacement);
+  reverseConvert = (to: string) => to.replaceAll(this.replacement, this.search);
+}

package/src/converters/RowTypeConverter.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import type { Cell } from "./Cell.ts";
+import { TypeConverter } from "./TypeConverter.ts";
+import { MetaDataRowTypeConverter } from "./MetaDataRowTypeConverter.ts";
+import { RowTypeConverter } from "./RowTypeConverter.ts";
+
+class OnlyOne extends TypeConverter<Cell, Cell> {
+  convert = (value: Cell): Cell => value === 1;
+  reverseConvert = (value: Cell): Cell => value;
+}
+
+describe("MetaDataRowTypeConverter", () => {
+  it("convert and reverseConvert round trip", () => {
+    const converter = new MetaDataRowTypeConverter();
+    const item = converter.convert({ id: 7, username: "ada" });
+    const row = converter.reverseConvert(item);
+    expect(item).toEqual({ id: 7, username: "ada" });
+    expect(row).toEqual({ id: 7, username: "ada" });
+  });
+
+  it("lets field converters override", () => {
+    const converter = new MetaDataRowTypeConverter({ flag: new OnlyOne() });
+    const dest = converter.convert({ flag: 1, name: "a" });
+    expect(dest.flag).toBe(true);
+    expect(dest.name).toBe("a");
+    expect(converter.reverseConvert(dest).flag).toBe(true);
+  });
+
+  it("can construct a typed destination", () => {
+    const converter = new MetaDataRowTypeConverter({ flag: new OnlyOne() });
+    class Item {
+      flag = false;
+    }
+    expect(converter.convert({ flag: 1 }, Item)).toBeInstanceOf(Item);
+  });
+
+  it("keeps a null in a string field", () => {
+    class Item {
+      name = "";
+    }
+    const converter = new MetaDataRowTypeConverter<Item>();
+    expect(converter.convert({ name: null }, Item).name).toBeNull();
+  });
+
+  it("copies a reference id onto the nested object", () => {
+    class Item {
+      Type: { Id?: number; id?: number } = { Id: 0 };
+    }
+    const converter = new MetaDataRowTypeConverter<Item>();
+    converter.references.add("Type");
+    const nested = converter.convert({ Type: 4 }, Item);
+    expect(nested.Type).toEqual({ Id: 4 });
+    class Bare {
+      Type = 0;
+    }
+    const bare = new MetaDataRowTypeConverter<Bare>();
+    bare.references.add("Type");
+    expect(bare.convert({ Type: 4 }, Bare).Type).toEqual({ id: 4 });
+    expect(converter.reverseConvert(Object.assign(new Item(), { Type: { Id: 3 } })).Type).toBe(3);
+    expect(converter.reverseConvert(Object.assign(new Item(), { Type: { id: 5 } })).Type).toBe(5);
+    expect(converter.reverseConvert(Object.assign(new Item(), { Type: undefined as never })).Type).toBeUndefined();
+    class Flip extends TypeConverter<Cell, Cell> {
+      convert = (value: Cell): Cell => value;
+      reverseConvert = (): Cell => 7;
+    }
+    const flagged = new MetaDataRowTypeConverter<Item>({ Type: new Flip() });
+    flagged.references.add("Type");
+    expect(flagged.reverseConvert(Object.assign(new Item(), { Type: { Id: 1 } })).Type).toBe(7);
+  });
+});
+
+describe("RowTypeConverter", () => {
+  it("converts named columns and leaves the rest", () => {
+    const flag = new OnlyOne();
+    const converter = RowTypeConverter.from({ bool: flag }, { on: "bool", missing: "nope" });
+    expect(converter.convert({ on: 1, name: "a" })).toEqual({ on: true, name: "a" });
+    expect(converter.reverseConvert({ on: true, name: "a" })).toEqual({ on: true, name: "a" });
+  });
+});

package/src/converters/RowTypeConverter.ts

@@ -0,0 +1,33 @@
+import type { Cell, Cells } from "./Cell.ts";
+import { TypeConverter } from "./TypeConverter.ts";
+
+export class RowTypeConverter extends TypeConverter<Cells, Cells> {
+  constructor(readonly fields: Record<string, TypeConverter<Cell, Cell>>) {
+    super();
+  }
+
+  static from(
+    converters: Record<string, TypeConverter<Cell, Cell>>,
+    columns: Record<string, string>,
+  ): RowTypeConverter {
+    const fields: Record<string, TypeConverter<Cell, Cell>> = {};
+    for (const [name, type] of Object.entries(columns)) {
+      const converter = converters[type];
+      if (converter) fields[name] = converter;
+    }
+    return new RowTypeConverter(fields);
+  }
+
+  convert = (from: Cells): Cells => this.apply(from, false);
+
+  reverseConvert = (to: Cells): Cells => this.apply(to, true);
+
+  private apply(row: Cells, reverse: boolean): Cells {
+    return Object.fromEntries(
+      Object.entries(row).map(([name, value]) => {
+        const converter = this.fields[name];
+        return [name, converter ? (reverse ? converter.reverseConvert(value) : converter.convert(value)) : value];
+      }),
+    );
+  }
+}

package/src/converters/ToLowerCaseConverter.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { ToLowerCaseConverter } from "./ToLowerCaseConverter.ts";
+
+describe("ToLowerCaseConverter", () => {
+  it("lowers", () => {
+    expect(new ToLowerCaseConverter().convert("ADA")).toBe("ada");
+    expect(new ToLowerCaseConverter().reverseConvert("ADA")).toBe("ADA");
+  });
+});

package/src/converters/ToLowerCaseConverter.ts

@@ -0,0 +1,4 @@
+export class ToLowerCaseConverter {
+  convert = (from: string) => from.toLowerCase();
+  reverseConvert = (to: string) => to;
+}

package/src/converters/ToUpperCaseConverter.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { ToUpperCaseConverter } from "./ToUpperCaseConverter.ts";
+
+describe("ToUpperCaseConverter", () => {
+  it("uppers", () => {
+    expect(new ToUpperCaseConverter().convert("ada")).toBe("ADA");
+    expect(new ToUpperCaseConverter().reverseConvert("ada")).toBe("ada");
+  });
+});

package/src/converters/ToUpperCaseConverter.ts

@@ -0,0 +1,4 @@
+export class ToUpperCaseConverter {
+  convert = (from: string) => from.toUpperCase();
+  reverseConvert = (to: string) => to;
+}

package/src/converters/TypeConverter.ts

@@ -0,0 +1,6 @@
+import type { Cells } from "./Cell.ts";
+
+export abstract class TypeConverter<To = Cells, From = Cells> {
+  abstract convert(from: From): To;
+  abstract reverseConvert(to: To): From;
+}

package/src/createCRUDRepositoryOptions.ts

@@ -0,0 +1,21 @@
+import type { Cell } from "./converters/Cell.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import type { TypeConverter } from "./converters/TypeConverter.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+import {
+  createReadonlyRepositoryMappingOptions,
+  fieldNamesOf,
+} from "./createReadonlyRepositoryMappingOptions.ts";
+
+export { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.ts";
+
+export const defaultId = (fields: string[]): string[] =>
+  fields.includes("id") ? ["id"] : fields.includes("Id") ? ["Id"] : [];
+
+export const createCRUDRepositoryOptions = <T>(
+  type: Constructable<T>,
+  rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>,
+): CRUDRepositoryOptions<T> => ({
+  ...createReadonlyRepositoryMappingOptions(type, rowTypeConverters),
+  ids: defaultId(fieldNamesOf(type)),
+});

package/src/createReadonlyRepositoryMappingOptions.ts

@@ -0,0 +1,26 @@
+import type { Cell } from "./converters/Cell.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import type { TypeConverter } from "./converters/TypeConverter.ts";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
+
+type FieldSource = Record<string, string | number | boolean | bigint | null | object>;
+
+export const fieldNamesOf = <T>(type: Constructable<T>): string[] => {
+  const instance = new type() as FieldSource;
+  return Object.keys(instance).filter((key) => {
+    const value = instance[key];
+    if (Array.isArray(value)) return false;
+    if (value !== null && typeof value === "object" && !(value instanceof Date) && !(value instanceof Uint8Array))
+      return "id" in value || "Id" in value;
+    return true;
+  });
+};
+
+export const createReadonlyRepositoryMappingOptions = <T>(
+  type: Constructable<T>,
+  rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>,
+): ReadonlyRepositoryMappingOptions<T> => ({
+  type,
+  entity: type.name,
+  rowTypeConverters,
+});

package/src/dotEnv.test.ts

@@ -0,0 +1,21 @@
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { DotEnv } from "./dotEnv.ts";
+
+describe("DotEnv", () => {
+  it("parses keys and skips comments", () => {
+    expect(DotEnv.parse("# hi\n\nPROVIDER=sqlite\nDATASOURCE_URL=sqlite:///:memory:\n")).toEqual({
+      PROVIDER: "sqlite",
+      DATASOURCE_URL: "sqlite:///:memory:",
+    });
+    expect(DotEnv.parse("=skip\nKEY=value")).toEqual({ KEY: "value" });
+    expect(DotEnv.load("missing.env")).toEqual({});
+    const dir = mkdtempSync(join(tmpdir(), "ds-"));
+    const path = join(dir, ".env");
+    writeFileSync(path, "PROVIDER=sqlite\n");
+    expect(DotEnv.load(path)).toEqual({ PROVIDER: "sqlite" });
+    rmSync(dir, { recursive: true });
+  });
+});

package/src/dotEnv.ts

@@ -0,0 +1,16 @@
+import { existsSync, readFileSync } from "node:fs";
+import type { DatasourceOptions } from "./DatasourceOptions.ts";
+
+export const DotEnv = {
+  parse: (text: string): DatasourceOptions =>
+    Object.fromEntries(
+      text
+        .split(/\r?\n/)
+        .map((raw) => raw.trimStart().split("=", 2))
+        .filter((parts): parts is [string, string] =>
+          parts.length === 2 && !parts[0].startsWith("#") && parts[0].trim() !== "")
+        .map(([key, value]) => [key.trim(), value]),
+    ),
+  load: (path = ".env"): DatasourceOptions =>
+    existsSync(path) ? DotEnv.parse(readFileSync(path, "utf8")) : {},
+};