@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/converters/PluralizerConverter.ts

@@ -1,67 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

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

package/src/converters/ToUpperCaseConverter.test.ts

@@ -1,9 +0,0 @@
-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

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

package/src/converters/TypeConverter.ts

@@ -1,6 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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")) : {},
-};