@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/converters/DefaultValueConverter.js

@@ -0,0 +1,183 @@
+export const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+const NUMERIC_LITERAL_TYPES = new Set([
+    "number",
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "float",
+    "decimal",
+    "reference",
+]);
+const CALL_FORM = /^([A-Za-z]+)\('(.*)'\)$/;
+const quotedReverse = /^'(.*)'$/;
+const identity = (arg) => arg;
+const intLit = { spec: /^-?[0-9]+$/, specText: identity };
+const uintLit = { spec: /^[0-9]+$/, specText: identity };
+const floatLit = { spec: /^-?[0-9]+(\.[0-9]+)?$/, specText: identity };
+export const sqlStringLiteral = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const escapeRe = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const exact = (text) => new RegExp(`^${escapeRe(text)}$`);
+const quoted = (arg) => sqlStringLiteral(arg);
+const callTokenName = (name) => (name === "uuid" ? "Uuid" : name);
+const token = (specToken, native, reverse) => ({
+    ...specToken,
+    native,
+    reverse,
+});
+const NUMERIC_TYPES = [
+    "number",
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "float",
+    "decimal",
+];
+export class DefaultValueConverter {
+    static spec = {
+        string: { String: { spec: /^.*$/, specText: identity } },
+        character: { String: { spec: /^.+$/, specText: identity } },
+        number: { Numeric: intLit },
+        integer: { Numeric: intLit },
+        unsignedinteger: { Numeric: uintLit },
+        smallinteger: { Numeric: intLit },
+        unsignedsmallinteger: { Numeric: uintLit },
+        biginteger: { Numeric: intLit },
+        unsignedbiginteger: { Numeric: uintLit },
+        float: { Numeric: floatLit },
+        decimal: { Numeric: floatLit, String: { spec: /^.*$/, specText: identity } },
+        boolean: { Boolean: { spec: /^(true|false)$/, specText: identity } },
+        datetime: {
+            Now: { spec: /^Now$/ },
+            UtcNow: { spec: /^UtcNow$/ },
+            DateTime: {
+                spec: /^DateTime\('[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|[+-][0-9]{2}:[0-9]{2})'\)$/,
+                specText: (arg) => `DateTime('${arg}')`,
+            },
+        },
+        binary: {
+            Hex: { spec: /^Hex\('([0-9a-fA-F]{2})*'\)$/, specText: (arg) => `Hex('${arg}')` },
+        },
+        uuid: {
+            NewId: { spec: /^NewId$/ },
+            Empty: { spec: /^Empty$/ },
+            Uuid: {
+                spec: /^uuid\('[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'\)$/,
+                specText: (arg) => `uuid('${arg}')`,
+            },
+        },
+        reference: {},
+    };
+    dictionary;
+    constructor(options) {
+        this.dictionary = DefaultValueConverter.dictionaryOf(options);
+    }
+    static parse(specType, value) {
+        if (value === undefined || value === null)
+            return { token: "None" };
+        const v = String(value);
+        const call = CALL_FORM.exec(v);
+        if (call !== null)
+            return { token: callTokenName(call[1]), arg: call[2] };
+        if (specType === "boolean") {
+            return { token: "Boolean", arg: typeof value === "boolean" ? value : v === "true" };
+        }
+        if (NUMERIC_LITERAL_TYPES.has(specType))
+            return { token: "Numeric", arg: v };
+        if (specType === "datetime") {
+            if (v === "Now")
+                return { token: "Now" };
+            if (v === "UtcNow")
+                return { token: "UtcNow" };
+            return { token: "DateTime", arg: v };
+        }
+        if (specType === "uuid") {
+            if (v === "NewId")
+                return { token: "NewId" };
+            if (v === "Empty")
+                return { token: "Empty" };
+            return { token: "Uuid", arg: v };
+        }
+        if (specType === "binary")
+            return { token: "Hex", arg: v };
+        return { token: "String", arg: v };
+    }
+    convert = (specType, text) => {
+        const parsed = DefaultValueConverter.parse(specType, text);
+        if (parsed.token === "None")
+            return null;
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        const entry = entries[parsed.token];
+        if (entry === undefined)
+            return null;
+        if (!entry.spec.test(text)) {
+            throw new Error(`default_value '${text}' is not a valid ${specType} ${parsed.token} default`);
+        }
+        const expr = entry.native(parsed.arg === undefined ? "" : String(parsed.arg));
+        return expr === "" ? null : expr;
+    };
+    reverseConvert = (specType, native) => {
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        for (const [name, entry] of Object.entries(entries)) {
+            const match = entry.reverse.exec(native);
+            if (match === null)
+                continue;
+            const arg = match[1] ?? "";
+            return entry.specText === undefined ? name : entry.specText(arg);
+        }
+        throw new Error(`Native default '${native}' is not a valid ${specType} default`);
+    };
+    static dictionaryOf = (opts) => {
+        const spec = DefaultValueConverter.spec;
+        const newId = opts.newId();
+        const now = opts.now();
+        const utcNow = opts.utcNow();
+        const numericEntries = (type) => {
+            const numeric = spec[type].Numeric;
+            return {
+                Numeric: token(numeric, (arg) => arg, numeric.spec),
+                String: token(numeric, (arg) => arg, numeric.spec),
+            };
+        };
+        const quotedString = {
+            String: token(spec.string.String, quoted, quotedReverse),
+            Numeric: token(spec.string.String, quoted, quotedReverse),
+        };
+        const dictionary = {
+            string: quotedString,
+            character: {
+                String: token(spec.character.String, quoted, quotedReverse),
+                Numeric: token(spec.character.String, quoted, quotedReverse),
+            },
+            boolean: {
+                Boolean: token(spec.boolean.Boolean, (arg) => (arg === "true" ? opts.booleanOn : opts.booleanOff), new RegExp(`^(${escapeRe(opts.booleanOn)}|${escapeRe(opts.booleanOff)})$`)),
+            },
+            datetime: {
+                Now: token(spec.datetime.Now, () => now, exact(now)),
+                UtcNow: token(spec.datetime.UtcNow, () => utcNow, exact(utcNow)),
+                DateTime: token(spec.datetime.DateTime, quoted, quotedReverse),
+            },
+            binary: {
+                Hex: token(spec.binary.Hex, opts.hex, opts.hexReverse),
+            },
+            uuid: {
+                NewId: token(spec.uuid.NewId, () => newId, exact(newId)),
+                Empty: token(spec.uuid.Empty, () => quoted(EMPTY_UUID), exact(quoted(EMPTY_UUID))),
+                Uuid: token(spec.uuid.Uuid, quoted, quotedReverse),
+            },
+            reference: {},
+        };
+        for (const type of NUMERIC_TYPES)
+            dictionary[type] = numericEntries(type);
+        return dictionary;
+    };
+}

package/dist/converters/DefaultValueOptions.d.ts

@@ -0,0 +1,9 @@
+export type DefaultValueOptions = {
+    newId: () => string;
+    now: () => string;
+    utcNow: () => string;
+    booleanOn: string;
+    booleanOff: string;
+    hex: (arg: string) => string;
+    hexReverse: RegExp;
+};

package/dist/converters/DefaultValueOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/DeterministicTypeConverter.d.ts

@@ -0,0 +1,11 @@
+import type { IMapping } from "./IMapping.js";
+import { type SpecField } from "./SpecField.js";
+import type { SpecFieldRules } from "./SpecFieldRules.js";
+export declare class DeterministicTypeConverter implements IMapping<string, string> {
+    #private;
+    readonly dictionary: Record<string, string>;
+    constructor(dictionary: Record<string, string>, rules: SpecFieldRules);
+    convert(from: string): string;
+    convert(from: SpecField): string;
+    reverseConvert: (native: string) => string;
+}

package/dist/converters/DeterministicTypeConverter.js

@@ -0,0 +1,74 @@
+const isUnlimited = (size) => size === "unlimited" || size === undefined || size === null;
+const sized = (unlimited, render, field) => isUnlimited(field.size) ? unlimited : render(Number(field.size));
+const charLen = (field) => field.size === undefined || field.size === null ? 1 : Number(field.size);
+const decimalPrecisionScale = (field) => {
+    const s = field.size;
+    if (Array.isArray(s) && s.length === 2) {
+        const [p, sc] = s;
+        if (!Number.isInteger(p) || !Number.isInteger(sc)) {
+            throw new Error(`decimal field "${field.name}" size must be [precision, scale] integers; got ${JSON.stringify(s)}`);
+        }
+        return [p, sc];
+    }
+    if (s === undefined || s === null)
+        return null;
+    throw new Error(`decimal field "${field.name}" size must be [precision, scale] tuple; got ${JSON.stringify(s)}`);
+};
+export class DeterministicTypeConverter {
+    dictionary;
+    #reverse;
+    #rules;
+    constructor(dictionary, rules) {
+        this.dictionary = dictionary;
+        this.#rules = rules;
+        this.#reverse = new Map();
+        for (const [specType, native] of Object.entries(dictionary)) {
+            const existing = this.#reverse.get(native);
+            if (existing === undefined)
+                this.#reverse.set(native, [specType]);
+            else
+                existing.push(specType);
+        }
+    }
+    convert(from) {
+        if (typeof from === "string") {
+            const native = this.dictionary[from];
+            if (native === undefined)
+                throw new Error(`Unknown spec field type: ${from}`);
+            return native;
+        }
+        const field = from;
+        const row = this.#rules;
+        if (field.type === "string")
+            return sized(row.stringUnlimited, row.stringSized, field);
+        if (field.type === "character" && row.character !== undefined) {
+            return `${row.character}(${charLen(field)})`;
+        }
+        if (field.type === "decimal" && row.decimal !== undefined) {
+            const rule = row.decimal;
+            const ps = decimalPrecisionScale(field);
+            if (rule.kind === "required") {
+                if (!ps) {
+                    throw new Error(`decimal field "${field.name}" requires size: [precision, scale] for ${row.dialectName ?? "sql"}`);
+                }
+                return `${rule.type}(${ps[0]}, ${ps[1]})`;
+            }
+            return ps ? `${rule.type}(${ps[0]}, ${ps[1]})` : rule.fallback;
+        }
+        if (field.type === "binary") {
+            if (row.binarySized !== undefined && row.binaryUnlimited !== undefined) {
+                return sized(row.binaryUnlimited, row.binarySized, field);
+            }
+        }
+        return this.convert(field.type);
+    }
+    reverseConvert = (native) => {
+        const specTypes = this.#reverse.get(native);
+        if (specTypes === undefined)
+            throw new Error(`Unknown native field type: ${native}`);
+        if (specTypes.length > 1) {
+            throw new Error(`Native field type ${native} maps to multiple spec types: ${specTypes.join(", ")}`);
+        }
+        return specTypes[0];
+    };
+}

package/dist/converters/IMapping.d.ts

@@ -0,0 +1,4 @@
+export interface IMapping<TFrom, TTo> {
+    convert(from: TFrom): TTo;
+    reverseConvert(to: TTo): TFrom;
+}

package/dist/converters/IMapping.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/MetaDataRowTypeConverter.d.ts

@@ -0,0 +1,14 @@
+import type { Cell, Cells } from "./Cell.js";
+import { TypeConverter } from "./TypeConverter.js";
+import type { Constructable } from "./Constructable.js";
+import type { IMapper } from "../mappers/IMapper.js";
+export declare class MetaDataRowTypeConverter<T = Cells> extends TypeConverter<T, Cells> {
+    fields: Record<string, TypeConverter<Cell, Cell>>;
+    references: Set<string>;
+    referenceColumns: IMapper<string, string>;
+    shouldCoerceId: boolean;
+    constructor(fields?: Record<string, TypeConverter<Cell, Cell>>);
+    convert: (row: Cells, type?: Constructable<T>) => T;
+    reverseConvert: (row: T) => Cells;
+    private converted;
+}

package/dist/converters/MetaDataRowTypeConverter.js

@@ -0,0 +1,71 @@
+import { TypeConverter } from "./TypeConverter.js";
+import { IdentityMapper } from "../mappers/IdentityMapper.js";
+const scalarId = (value) => {
+    if (value === undefined || value === null || typeof value !== "object" || value instanceof Date || value instanceof Uint8Array)
+        return value === undefined ? undefined : value;
+    const record = value;
+    return record.Id !== undefined ? record.Id : record.id;
+};
+export class MetaDataRowTypeConverter extends TypeConverter {
+    fields;
+    references = new Set();
+    referenceColumns = new IdentityMapper();
+    shouldCoerceId = false;
+    constructor(fields = {}) {
+        super();
+        this.fields = { ...fields };
+    }
+    convert = (row, type) => {
+        const blank = type ? new type() : {};
+        const cells = Object.fromEntries(Object.entries(row).filter(([key, value]) => {
+            if (this.references.has(key))
+                return false;
+            const current = blank[key];
+            return !(typeof current === "string" && typeof value !== "string" && value !== null);
+        }));
+        const dest = Object.assign(blank, cells);
+        const record = dest;
+        for (const [key, value] of Object.entries(row)) {
+            if (this.references.has(key)) {
+                const current = record[key];
+                const target = current !== null && typeof current === "object" && !Array.isArray(current)
+                    ? current
+                    : {};
+                const id = "Id" in target ? "Id" : "id";
+                target[id] = value;
+                record[key] = target;
+                continue;
+            }
+            const converter = this.fields[key];
+            if (converter)
+                record[key] = converter.convert(value);
+        }
+        return dest;
+    };
+    reverseConvert = (row) => {
+        const cells = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (Array.isArray(value))
+                continue;
+            if (value !== null &&
+                typeof value === "object" &&
+                !(value instanceof Date) &&
+                !(value instanceof Uint8Array) &&
+                !this.references.has(key))
+                continue;
+            if (this.references.has(key)) {
+                const id = scalarId(value);
+                if (id !== undefined && id !== null)
+                    cells[this.referenceColumns.map(key)] = this.converted(key, id);
+                continue;
+            }
+            const converter = this.fields[key];
+            cells[key] = converter ? converter.reverseConvert(value) : value;
+        }
+        return cells;
+    };
+    converted = (key, value) => {
+        const converter = this.fields[key];
+        return converter ? converter.reverseConvert(value) : value;
+    };
+}

package/dist/converters/PluralizerConverter.d.ts

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

package/dist/converters/PluralizerConverter.js

@@ -0,0 +1,54 @@
+const uncountable = new Set(["sheep", "fish", "series", "species", "deer", "news"]);
+const irregular = {
+    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) => "aeiou".includes(c);
+const consonant = (c) => /[a-z]/.test(c) && !vowel(c);
+const yies = (word) => word.length >= 4 && word.endsWith("ies") && consonant(word[word.length - 4]);
+const consonantY = (word) => word.length >= 2 && word.endsWith("y") && consonant(word[word.length - 2]);
+const sibilant = (word) => 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) => word.length > 2 && word.endsWith("es") && sibilant(word.slice(0, -2));
+const restore = (original, result) => original[0] === original[0].toUpperCase()
+    ? result[0].toUpperCase() + result.slice(1)
+    : result;
+const plural = (word) => 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) => 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, transform) => word.length === 0 ? word : restore(word, transform(word.toLowerCase()));
+export class PluralizerConverter {
+    convert = (from) => apply(from, plural);
+    reverseConvert = (to) => apply(to, singular);
+}

package/dist/converters/RegexConverter.d.ts

@@ -0,0 +1,7 @@
+export declare class RegexConverter {
+    readonly regex: RegExp;
+    readonly replacement: string;
+    constructor(pattern: string | RegExp, replacement: string);
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/RegexConverter.js

@@ -0,0 +1,12 @@
+export class RegexConverter {
+    regex;
+    replacement;
+    constructor(pattern, replacement) {
+        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) => from.replace(this.regex, this.replacement);
+    reverseConvert = (to) => to;
+}

package/dist/converters/ReplaceConverter.d.ts

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

package/dist/converters/ReplaceConverter.js

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

package/dist/converters/RowTypeConverter.d.ts

@@ -0,0 +1,10 @@
+import type { Cell, Cells } from "./Cell.js";
+import { TypeConverter } from "./TypeConverter.js";
+export declare class RowTypeConverter extends TypeConverter<Cells, Cells> {
+    readonly fields: Record<string, TypeConverter<Cell, Cell>>;
+    constructor(fields: Record<string, TypeConverter<Cell, Cell>>);
+    static from(converters: Record<string, TypeConverter<Cell, Cell>>, columns: Record<string, string>): RowTypeConverter;
+    convert: (from: Cells) => Cells;
+    reverseConvert: (to: Cells) => Cells;
+    private apply;
+}

package/dist/converters/RowTypeConverter.js

@@ -0,0 +1,25 @@
+import { TypeConverter } from "./TypeConverter.js";
+export class RowTypeConverter extends TypeConverter {
+    fields;
+    constructor(fields) {
+        super();
+        this.fields = fields;
+    }
+    static from(converters, columns) {
+        const fields = {};
+        for (const [name, type] of Object.entries(columns)) {
+            const converter = converters[type];
+            if (converter)
+                fields[name] = converter;
+        }
+        return new RowTypeConverter(fields);
+    }
+    convert = (from) => this.apply(from, false);
+    reverseConvert = (to) => this.apply(to, true);
+    apply(row, reverse) {
+        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/dist/converters/SpecField.d.ts

@@ -0,0 +1,7 @@
+export type FieldSize = number | number[] | "unlimited" | null;
+export type SpecField = {
+    type: string;
+    name?: string;
+    size?: FieldSize;
+    defaultValue?: string | boolean | number | null;
+};

package/dist/converters/SpecField.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/SpecFieldRules.d.ts

@@ -0,0 +1,17 @@
+export type DecimalRule = {
+    kind: "optional";
+    type: string;
+    fallback: string;
+} | {
+    kind: "required";
+    type: string;
+};
+export type SpecFieldRules = {
+    dialectName?: string;
+    stringUnlimited: string;
+    stringSized: (n: number) => string;
+    character?: "CHAR" | "NCHAR";
+    decimal?: DecimalRule;
+    binaryUnlimited?: string;
+    binarySized?: (n: number) => string;
+};

package/dist/converters/SpecFieldRules.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/ToLowerCaseConverter.d.ts

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

package/dist/converters/ToLowerCaseConverter.js

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

package/dist/converters/ToUpperCaseConverter.d.ts

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

package/dist/converters/ToUpperCaseConverter.js

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

package/dist/converters/TypeConverter.d.ts

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

package/dist/converters/TypeConverter.js

@@ -0,0 +1,2 @@
+export class TypeConverter {
+}

package/dist/createCRUDRepositoryOptions.d.ts

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

package/dist/createCRUDRepositoryOptions.js

@@ -0,0 +1,7 @@
+import { createReadonlyRepositoryMappingOptions, fieldNamesOf, } from "./createReadonlyRepositoryMappingOptions.js";
+export { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.js";
+export const defaultId = (fields) => fields.includes("id") ? ["id"] : fields.includes("Id") ? ["Id"] : [];
+export const createCRUDRepositoryOptions = (type, rowTypeConverters) => ({
+    ...createReadonlyRepositoryMappingOptions(type, rowTypeConverters),
+    ids: defaultId(fieldNamesOf(type)),
+});

package/dist/createReadonlyRepositoryMappingOptions.d.ts

@@ -0,0 +1,6 @@
+import type { Cell } from "./converters/Cell.js";
+import type { Constructable } from "./converters/Constructable.js";
+import type { TypeConverter } from "./converters/TypeConverter.js";
+import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+export declare const fieldNamesOf: <T>(type: Constructable<T>) => string[];
+export declare const createReadonlyRepositoryMappingOptions: <T>(type: Constructable<T>, rowTypeConverters?: Record<string, TypeConverter<Cell, Cell>>) => ReadonlyRepositoryMappingOptions<T>;

package/dist/createReadonlyRepositoryMappingOptions.js

@@ -0,0 +1,16 @@
+export const fieldNamesOf = (type) => {
+    const instance = new type();
+    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 = (type, rowTypeConverters) => ({
+    type,
+    entity: type.name,
+    rowTypeConverters,
+});

package/dist/dotEnv.d.ts

@@ -0,0 +1,5 @@
+import type { DatasourceOptions } from "./DatasourceOptions.js";
+export declare const DotEnv: {
+    parse: (text: string) => DatasourceOptions;
+    load: (path?: string) => DatasourceOptions;
+};

package/dist/dotEnv.js

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