@deterministic-code/datasources 0.1.0 → 0.1.2

package/dist/StatementMappers.js

@@ -0,0 +1,88 @@
+import { DeleteStatement } from "./statements/DeleteStatement.js";
+import { InsertStatement } from "./statements/InsertStatement.js";
+import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.js";
+import { SelectStatement } from "./statements/SelectStatement.js";
+import { UpdateStatement } from "./statements/UpdateStatement.js";
+import { Where } from "./statements/Where.js";
+export class StatementMappers {
+    entityMappers;
+    propertyMappers;
+    constructor(entityMappers, propertyMappers) {
+        this.entityMappers = entityMappers;
+        this.propertyMappers = propertyMappers;
+    }
+    map = (property) => {
+        const dot = lastDot(property);
+        if (dot < 0)
+            return this.propertyMappers.map(property);
+        const qualifier = property.slice(0, dot);
+        const name = property.slice(dot + 1);
+        const mapped = this.propertyMappers.map(name);
+        if (mapped !== name && mapped.includes("."))
+            return mapped;
+        const table = this.entityMappers.map(qualifier);
+        return table === qualifier && mapped === name ? property : `${table}.${mapped}`;
+    };
+    reverseMap = (key) => {
+        const reversed = this.propertyMappers.reverseMap(key);
+        if (reversed !== key && this.propertyMappers.map(reversed) === key)
+            return reversed;
+        const dot = lastDot(key);
+        if (dot < 0)
+            return reversed;
+        const column = key.slice(dot + 1);
+        const name = this.propertyMappers.reverseMap(column);
+        return name !== column && this.propertyMappers.map(name) === column ? name : reversed;
+    };
+    column = (property) => this.map(property);
+    property = (key) => this.reverseMap(key);
+    apply = (query, cell) => {
+        if (query instanceof SelectStatement && query.table)
+            return new SelectStatement({
+                distinct: query.distinct,
+                table: this.entityMappers.map(query.table),
+                fields: query.fields.map(this.mapSelectField),
+                where: query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
+                joins: query.joins.map((join) => ({
+                    kind: join.kind,
+                    table: this.entityMappers.map(join.table),
+                    on: join.on ? new Where(join.on).map(this.column, cell).condition : undefined,
+                })),
+                groupBy: query.groupBy.map(this.column),
+                having: query.having instanceof Where ? this.applyWhere(query.having, cell) : query.having,
+                orderBy: query.orderBy.map((order) => ({ column: this.column(order.column), direction: order.direction })),
+                limit: query.limit,
+                offset: query.offset,
+            });
+        if (query instanceof InsertStatement && query.table !== undefined)
+            return new InsertStatement(this.entityMappers.map(query.table), query.fields.map((field) => ({ name: this.column(field.name), value: field.value })));
+        if (query instanceof UpdateStatement && query.table !== undefined)
+            return new UpdateStatement(this.entityMappers.map(query.table), query.fields.map((field) => ({ name: this.column(field.name), value: field.value })), query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where);
+        if (query instanceof DeleteStatement && query.table !== undefined)
+            return new DeleteStatement(this.entityMappers.map(query.table), query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where);
+        if (query instanceof SelectInsertedIdStatement)
+            return new SelectInsertedIdStatement(this.entityMappers.map(query.table), this.column(query.column));
+        return query;
+    };
+    applyWhere = (where, cell) => where instanceof Where ? where.map(this.column, cell) : where;
+    mapSelectField = (field) => {
+        const asIndex = field.toUpperCase().indexOf(" AS ");
+        if (asIndex >= 0) {
+            const expression = field.slice(0, asIndex).trim();
+            const alias = field.slice(asIndex + 4).trim();
+            return `${this.map(expression)} AS ${alias}`;
+        }
+        return this.map(field);
+    };
+}
+const lastDot = (name) => {
+    let quoted = false;
+    let dot = -1;
+    for (let i = 0; i < name.length; i++) {
+        if (name[i] === '"')
+            quoted = !quoted;
+        if (name[i] === "." && !quoted)
+            dot = i;
+    }
+    return dot;
+};

package/dist/StoredEnrichment.d.ts

@@ -0,0 +1,11 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { Row } from "./Row.js";
+export type ApplyEnrichment<T extends object = object> = (parents: T[], sources?: (Row | undefined)[]) => Promise<void>;
+export declare class StoredEnrichment<T extends object = object> {
+    readonly enrichment: Enrichment;
+    apply: ApplyEnrichment<T>;
+    persist?: ICRUDRepository<object>;
+    link?: ICRUDRepository<object>;
+    constructor(enrichment: Enrichment, apply: ApplyEnrichment<T>, persist?: ICRUDRepository<object>, link?: ICRUDRepository<object>);
+}

package/dist/StoredEnrichment.js

@@ -0,0 +1,12 @@
+export class StoredEnrichment {
+    enrichment;
+    apply;
+    persist;
+    link;
+    constructor(enrichment, apply, persist, link) {
+        this.enrichment = enrichment;
+        this.apply = apply;
+        this.persist = persist;
+        this.link = link;
+    }
+}

package/dist/StoredProcedureBulkWriteStrategy.d.ts

@@ -0,0 +1,27 @@
+import type { Response } from "./Response.js";
+import type { IWhere } from "./statements/IWhere.js";
+import type { CRUDRepository } from "./CRUDRepository.js";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+import type { ICommand } from "./ICommand.js";
+import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.js";
+export declare class StoredProcedureBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
+    private readonly createName;
+    private readonly updateName;
+    private readonly deleteName;
+    repo: CRUDRepository<T>;
+    command: ICommand;
+    options: CRUDRepositoryOptions<T>;
+    attach: (command: ICommand, options: CRUDRepositoryOptions<T>) => void;
+    constructor(createName: string, updateName: string, deleteName: string);
+    create: (items: T[]) => Promise<Response>;
+    update: (items: T[], _byWhere: IWhere | undefined) => Promise<Response>;
+    delete: (items: T[], _byWhere: IWhere | undefined) => Promise<Response>;
+    private then;
+    private call;
+    private ids;
+    private rowOf;
+    private identity;
+    private applyIds;
+    private column;
+    private reverse;
+}

package/dist/StoredProcedureBulkWriteStrategy.js

@@ -0,0 +1,143 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.js";
+import { execute } from "./ICommand.js";
+import { repositoryParts } from "./CRUDRepositoryBuilder.js";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { afterBulkWrite } from "./BulkWriteEnrichment.js";
+import { ParameterDirection } from "./ParameterDirection.js";
+const empty = () => ({ result: null, rowsAffected: 0 });
+const json = (rows) => `[${rows.map(object).join(",")}]`;
+const object = (row) => `{${Object.entries(row)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${quote(key)}:${scalar(value)}`)
+    .join(",")}}`;
+const scalar = (value) => {
+    if (value === null || value === undefined)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return Number.isFinite(value) ? JSON.stringify(value) : fail();
+    if (typeof value === "bigint")
+        return value.toString();
+    if (typeof value === "string")
+        return quote(value);
+    if (value instanceof Date)
+        return quote(roundTrip(value));
+    if (value instanceof Uint8Array)
+        return quote(base64(value));
+    return fail();
+};
+const fail = () => {
+    throw new DatasourceError("Unsupported bulk payload value");
+};
+const roundTrip = (date) => date.toISOString().replace(/\.(\d{3})Z$/, (_, fraction) => `.${fraction}0000Z`);
+const base64 = (bytes) => btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""));
+const quote = (text) => {
+    let result = "\"";
+    for (const ch of text) {
+        result += ({
+            "\\": "\\\\",
+            "\"": "\\\"",
+            "\b": "\\b",
+            "\f": "\\f",
+            "\n": "\\n",
+            "\r": "\\r",
+            "\t": "\\t",
+        }[ch] ?? (ch < " " ? `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}` : ch));
+    }
+    return `${result}"`;
+};
+export class StoredProcedureBulkWriteStrategy {
+    createName;
+    updateName;
+    deleteName;
+    repo;
+    command;
+    options;
+    attach = (command, options) => {
+        this.command = command;
+        this.options = options;
+    };
+    constructor(createName, updateName, deleteName) {
+        this.createName = createName;
+        this.updateName = updateName;
+        this.deleteName = deleteName;
+    }
+    create = (items) => this.then(this.call(this.createName, items, true), items, "create");
+    update = (items, _byWhere) => this.then(this.call(this.updateName, items), items, "update");
+    delete = (items, _byWhere) => this.then(this.call(this.deleteName, items), items, "delete");
+    then = async (write, items, mode) => {
+        const response = await write;
+        await afterBulkWrite(this.repo, this.options, items, mode);
+        return response;
+    };
+    call = async (name, items, generated = false) => {
+        if (items.length === 0)
+            return empty();
+        const payload = { name: "payload", value: json(items.map((item) => this.rowOf(item, generated))) };
+        const parameters = generated && this.ids().length === 1
+            ? [payload, { name: "ids", value: null, direction: ParameterDirection.InputOutput }]
+            : [payload];
+        const response = await execute(this.command, new ExecuteStoredProcedureStatement(name, parameters), parameters);
+        if (generated)
+            this.applyIds(items, response.parameters);
+        return response;
+    };
+    ids = () => this.options.ids ?? this.repo.ids ?? ["id"];
+    rowOf = (item, create = false) => {
+        const stored = this.reverse(item);
+        const statements = repositoryParts(this.command.connection, this.options).statements;
+        const row = {};
+        for (const name of statements.readColumns) {
+            if (create && this.identity(name) && !assigned(stored[name] ?? stored[this.ids()[0]]))
+                continue;
+            const match = Object.entries(stored).find(([key]) => this.column(key) === name);
+            row[name] = match?.[1] ?? null;
+        }
+        return row;
+    };
+    identity = (column) => this.ids().length === 1 && this.ids()[0] === column;
+    applyIds = (items, parameters) => {
+        if (this.ids().length !== 1)
+            return;
+        const found = parameters?.find((parameter) => parameter.name === "ids");
+        const list = parseIds(found?.value);
+        const column = this.ids()[0];
+        for (let index = 0; index < items.length && index < list.length; index++)
+            stamp(items[index], column, list[index]);
+    };
+    column = (property) => this.options.propertyMappings?.map(property) ?? property;
+    reverse = (item) => {
+        const objects = this.options.objectConverter ?? new MetaDataRowTypeConverter();
+        const row = objects.reverseConvert(item);
+        return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
+    };
+}
+const assigned = (value) => {
+    if (value === null || value === undefined)
+        return false;
+    if (value === 0 || value === 0n)
+        return false;
+    if (typeof value === "string")
+        return value.length > 0;
+    return true;
+};
+const parseIds = (value) => {
+    const text = typeof value === "string" ? value.trim()
+        : typeof value === "number" || typeof value === "bigint" ? String(value)
+            : "";
+    if (text === "" || text === "[]" || text === "null")
+        return [];
+    return text
+        .replace(/^\[/, "")
+        .replace(/\]$/, "")
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => Number(part));
+};
+const stamp = (item, column, id) => {
+    const key = column in item ? column : "id" in item ? "id" : "Id" in item ? "Id" : column;
+    item[key] = id;
+};

package/dist/StreamingReader.d.ts

@@ -0,0 +1,16 @@
+import type { Cells } from "./converters/Cell.js";
+import type { IReader } from "./IReader.js";
+export declare class StreamingReader implements IReader<Cells> {
+    private readonly pull;
+    private readonly advance;
+    private readonly close;
+    current: Cells | undefined;
+    private closed;
+    constructor(pull: () => Promise<Cells | undefined>, advance: () => Promise<boolean>, close?: () => Promise<void>);
+    next(): Promise<boolean>;
+    read(): AsyncIterable<Cells>;
+    nextResult(): Promise<boolean>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}
+export declare const statementReader: (statements: readonly string[], load: (sql: string) => AsyncIterable<Cells>) => StreamingReader;

package/dist/StreamingReader.js

@@ -0,0 +1,53 @@
+import { readerToAsyncIterable } from "./readerToAsyncIterable.js";
+export class StreamingReader {
+    pull;
+    advance;
+    close;
+    current = undefined;
+    closed = false;
+    constructor(pull, advance, close = async () => { }) {
+        this.pull = pull;
+        this.advance = advance;
+        this.close = close;
+    }
+    async next() {
+        this.current = await this.pull();
+        return this.current !== undefined;
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    async nextResult() {
+        this.current = undefined;
+        return this.advance();
+    }
+    async dispose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        await this.close();
+    }
+    [Symbol.asyncDispose] = () => this.dispose();
+}
+export const statementReader = (statements, load) => {
+    let index = 0;
+    let rows;
+    const closeRows = async () => {
+        await rows?.return?.();
+        rows = undefined;
+    };
+    return new StreamingReader(async () => {
+        if (index >= statements.length)
+            return undefined;
+        const sql = statements[index];
+        if (!sql)
+            return undefined;
+        rows ??= load(sql)[Symbol.asyncIterator]();
+        const step = await rows.next();
+        return step.done ? undefined : step.value;
+    }, async () => {
+        await closeRows();
+        index += 1;
+        return index < statements.length;
+    }, closeRows);
+};

package/dist/UnitOfWorkTransaction.d.ts

@@ -0,0 +1,12 @@
+import type { IConnection } from "./IConnection.js";
+import type { IUnitOfWork } from "./IUnitOfWork.js";
+export declare class UnitOfWorkTransaction implements IUnitOfWork {
+    private readonly connection;
+    private begun;
+    private transaction;
+    constructor(connection: IConnection);
+    begin: () => Promise<void>;
+    commit: () => Promise<void>;
+    abort: () => Promise<void>;
+    private release;
+}

package/dist/UnitOfWorkTransaction.js

@@ -0,0 +1,51 @@
+import { DatasourceError } from "./DatasourceError.js";
+const open = new WeakSet();
+export class UnitOfWorkTransaction {
+    connection;
+    begun = false;
+    transaction;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    begin = async () => {
+        if (this.begun)
+            throw new DatasourceError("Unit of work already begun");
+        this.begun = true;
+        if (open.has(this.connection))
+            return;
+        open.add(this.connection);
+        try {
+            this.transaction = await this.connection.startTransaction();
+        }
+        catch (error) {
+            open.delete(this.connection);
+            throw error;
+        }
+    };
+    commit = async () => {
+        if (!this.begun)
+            throw new DatasourceError("Unit of work has not begun");
+        const txn = this.transaction;
+        if (!txn)
+            return;
+        await txn.commit();
+        this.release();
+    };
+    abort = async () => {
+        if (!this.begun)
+            throw new DatasourceError("Unit of work has not begun");
+        const txn = this.transaction;
+        if (!txn)
+            return;
+        try {
+            await txn.abort();
+        }
+        finally {
+            this.release();
+        }
+    };
+    release() {
+        open.delete(this.connection);
+        this.transaction = undefined;
+    }
+}

package/dist/UpdateEnrichmentStrategy.d.ts

@@ -0,0 +1,18 @@
+import type { Enrichment } from "./Enrichment.js";
+import type { ICRUDRepository } from "./ICRUDRepository.js";
+import type { Scalar } from "./builders/Scalar.js";
+import { Where } from "./statements/index.js";
+export declare abstract class UpdateEnrichmentStrategy<T> {
+    abstract updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    abstract updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void>;
+    protected getCell: <TItem>(item: TItem, name: string) => Scalar | object | undefined;
+    protected presentCell: (value: Scalar | object | undefined) => value is Scalar;
+    protected payloadOf: <TChild extends object, TParent>(parent: TParent, into: string, enrichment?: Enrichment) => TChild[];
+    protected stampCell: <TItem extends object>(related: TItem, by: string, key: Scalar | object | undefined) => void;
+    protected hasKey: <TItem extends object>(item: TItem, keys: readonly string[]) => boolean;
+    protected keyOf: <TItem extends object>(item: TItem, keys: readonly string[]) => string;
+    protected namesOf: <TChild extends object>(writer: ICRUDRepository<TChild>, item: TChild) => readonly string[];
+    protected linkWhere: (association: NonNullable<Enrichment["association"]>, parentKey: Scalar, relatedKey: Scalar) => Where;
+    protected relatedIds: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar[];
+    protected requiredKey: <TParent>(parent: TParent, enrichment: Enrichment) => Scalar;
+}

package/dist/UpdateEnrichmentStrategy.js

@@ -0,0 +1,61 @@
+import { defaultId } from "./createCRUDRepositoryOptions.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { Operator, Where } from "./statements/index.js";
+export class UpdateEnrichmentStrategy {
+    getCell = (item, name) => item[name];
+    presentCell = (value) => value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
+    payloadOf = (parent, into, enrichment) => mapPayload(this.getCell(parent, into), enrichment);
+    stampCell = (related, by, key) => {
+        if (key === undefined || key === null || typeof key === "object")
+            return;
+        const current = this.getCell(related, by);
+        if (current !== null && typeof current === "object" && !Array.isArray(current)) {
+            const target = current;
+            const id = "Id" in target ? "Id" : "id";
+            target[id] = key;
+            return;
+        }
+        Object.assign(related, { [by]: key });
+    };
+    hasKey = (item, keys) => keys.length > 0 && keys.every((name) => this.presentCell(this.getCell(item, name)));
+    keyOf = (item, keys) => keys.map((name) => String(this.getCell(item, name) ?? "")).join("\u001f");
+    namesOf = (writer, item) => writer.ids.length > 0 ? writer.ids : defaultId(Object.keys(item));
+    linkWhere = (association, parentKey, relatedKey) => new Where(new Operator.And(new Operator.Equals(association.parent, parentKey), new Operator.Equals(association.related, relatedKey)));
+    relatedIds = (parent, enrichment) => {
+        const ids = [];
+        const seen = new Set();
+        for (const related of this.payloadOf(parent, enrichment.destinationProperty)) {
+            const id = this.getCell(related, enrichment.relatedKey);
+            if (!this.presentCell(id))
+                throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.relatedKey}"`);
+            const key = String(id);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            ids.push(id);
+        }
+        return ids;
+    };
+    requiredKey = (parent, enrichment) => {
+        const key = this.getCell(parent, enrichment.sourceProperty);
+        if (!this.presentCell(key))
+            throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.sourceProperty}"`);
+        return key;
+    };
+}
+const mapPayload = (value, enrichment) => {
+    if (value === undefined || value === null || typeof value === "string")
+        return [];
+    if (Array.isArray(value))
+        return value.filter((item) => item !== null && typeof item === "object");
+    if (enrichment?.type !== "dictionary" || typeof value !== "object")
+        return [];
+    const keyName = mapKeyName(enrichment.relatedKey);
+    const valueName = enrichment.relatedProperty ?? (keyName === "Key" ? "Value" : "value");
+    return Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, cell]) => cell !== null && typeof cell === "object" && !Array.isArray(cell)
+        ? { [keyName]: key, ...cell }
+        : { [keyName]: key, [valueName]: cell });
+};
+const mapKeyName = (relatedKey) => relatedKey.includes("_") || relatedKey[0] !== relatedKey[0]?.toUpperCase() ? "key" : "Key";

package/dist/WriteMode.js

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

package/dist/builders/Field.d.ts

@@ -0,0 +1,5 @@
+import type { Scalar } from "./Scalar.js";
+export interface Field {
+    name: string;
+    value: Scalar;
+}

package/dist/builders/Field.js

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

package/dist/builders/Scalar.js

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

package/dist/builders/index.d.ts

@@ -0,0 +1,2 @@
+export type { Field } from "./Field.js";
+export type { Scalar } from "./Scalar.js";

package/dist/builders/index.js

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

package/dist/collectAsync.d.ts

@@ -0,0 +1 @@
+export declare function collectAsync<T>(items: AsyncIterable<T>): Promise<T[]>;

package/dist/collectAsync.js

@@ -0,0 +1,7 @@
+export async function collectAsync(items) {
+    const collected = [];
+    for await (const item of items) {
+        collected.push(item);
+    }
+    return collected;
+}

package/dist/converters/Cell.d.ts

@@ -0,0 +1,2 @@
+export type Cell = string | number | boolean | bigint | Date | Uint8Array | null;
+export type Cells = Record<string, Cell>;

package/dist/converters/Cell.js

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

package/dist/converters/ChangeCasingConverter.d.ts

@@ -0,0 +1,7 @@
+export type Casing = "camelCase" | "capitalCase" | "constantCase" | "dotCase" | "kebabCase" | "noCase" | "pascalCase" | "pascalSnakeCase" | "pathCase" | "sentenceCase" | "snakeCase" | "trainCase";
+export declare class ChangeCasingConverter {
+    private readonly casing;
+    constructor(casing: Casing);
+    convert: (from: string) => string;
+    reverseConvert: (to: string) => string;
+}

package/dist/converters/ChangeCasingConverter.js

@@ -0,0 +1,46 @@
+const cap = (word) => word[0].toUpperCase() + word.slice(1);
+const sep = (c) => c === "_" || c === "." || c === "-" || c === "/" || /\s/.test(c);
+const upper = (c) => c !== c.toLowerCase();
+const lower = (c) => c !== c.toUpperCase();
+const letter = (c) => upper(c) || lower(c);
+const digit = (c) => c >= "0" && c <= "9";
+const words = (text) => {
+    const parts = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const split = sep(text[i]) ||
+            (i > 0 && lower(text[i - 1]) && upper(text[i])) ||
+            (i > 0 && i + 1 < text.length && upper(text[i - 1]) && upper(text[i]) && lower(text[i + 1])) ||
+            (i > 0 && letter(text[i - 1]) !== letter(text[i]) && (letter(text[i - 1]) || digit(text[i - 1])) && (letter(text[i]) || digit(text[i])));
+        if (!split)
+            continue;
+        if (i > start)
+            parts.push(text.slice(start, i));
+        start = sep(text[i]) ? i + 1 : i;
+    }
+    if (start < text.length)
+        parts.push(text.slice(start));
+    return parts.map((word) => word.toLowerCase()).filter((word) => word.length > 0);
+};
+const join = (parts, casing) => ({
+    camelCase: () => parts.map((word, i) => (i === 0 ? word : cap(word))).join(""),
+    capitalCase: () => parts.map(cap).join(" "),
+    constantCase: () => parts.map((word) => word.toUpperCase()).join("_"),
+    dotCase: () => parts.join("."),
+    kebabCase: () => parts.join("-"),
+    noCase: () => parts.join(" "),
+    pascalCase: () => parts.map(cap).join(""),
+    pascalSnakeCase: () => parts.map(cap).join("_"),
+    pathCase: () => parts.join("/"),
+    sentenceCase: () => parts.map((word, i) => (i === 0 ? cap(word) : word)).join(" "),
+    snakeCase: () => parts.join("_"),
+    trainCase: () => parts.map(cap).join("-"),
+}[casing]());
+export class ChangeCasingConverter {
+    casing;
+    constructor(casing) {
+        this.casing = casing;
+    }
+    convert = (from) => join(words(from), this.casing);
+    reverseConvert = (to) => to;
+}

package/dist/converters/Constructable.js

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

package/dist/converters/DefaultValueConverter.d.ts

@@ -0,0 +1,25 @@
+import type { DefaultValueOptions } from "./DefaultValueOptions.js";
+export declare const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+export type SpecToken = {
+    spec: RegExp;
+    specText?: (arg: string) => string;
+};
+export type DefaultEntry = SpecToken & {
+    native: (arg: string) => string;
+    reverse: RegExp;
+};
+type DefaultToken = {
+    token: string;
+    arg?: string | boolean;
+};
+export declare const sqlStringLiteral: (value: string | number | boolean | null | undefined) => string;
+export declare class DefaultValueConverter {
+    static readonly spec: Record<string, Record<string, SpecToken>>;
+    readonly dictionary: Record<string, Record<string, DefaultEntry>>;
+    constructor(options: DefaultValueOptions);
+    static parse(specType: string, value: unknown): DefaultToken;
+    convert: (specType: string, text: string) => string | null;
+    reverseConvert: (specType: string, native: string) => string;
+    private static dictionaryOf;
+}
+export {};