feat: create new parser to return readonly map when parsing connecton strings

dhensby · dhensby · commit 05bf6fec1c23 · 2025-06-07T10:31:25.000+01:00
diff --git a/src/parse.ts b/src/parse.ts
@@ -0,0 +1,106 @@
+import connectionStringParser from './parser/connection-string';
+
+type CoerceType = 'string' | 'number' | 'boolean';
+
+interface SchemaItem<T extends CoerceType = 'string'> {
+    type?: T;
+    default?: string | number | boolean;
+    aliases?: string[];
+}
+
+interface SchemaItemBoolean extends SchemaItem<'boolean'> {
+    type: 'boolean';
+    default?: boolean;
+}
+
+interface SchemaItemString extends SchemaItem<'string'> {
+    type: 'string';
+    default?: string;
+}
+
+interface SchemaItemNumber extends SchemaItem<'number'> {
+    type: 'number';
+    default?: number;
+}
+
+type SchemaDefinition = Record<string, SchemaItemString | SchemaItemNumber | SchemaItemBoolean>;
+
+class ConnectionString implements ReadonlyMap<string, string> {
+    readonly #connectionString: string;
+    readonly #parsed: ReadonlyMap<string, string>;
+    constructor(connectionString: string) {
+        this.#connectionString = connectionString.toString();
+        const parsed = connectionStringParser(this.#connectionString);
+        this.#parsed = new Map<string, string>(Object.entries(parsed));
+    }
+
+    get size(): number {
+        return this.#parsed.size;
+    }
+
+    // it would be really nice to be able to make this a generice (eg: get<string>) and that would then coerce the value
+    // see typia library for an example of something similar
+    get(key: string, coerceType: 'boolean'): boolean | undefined;
+    get(key: string, coerceType: 'number'): number | undefined;
+    get(key: string, coerceType?: 'string'): string | undefined;
+    get(key: string, coerceType?: CoerceType): string | number | boolean | undefined {
+        const val = this.#parsed.get(key);
+        coerceType ??= 'string';
+        if (typeof val === 'undefined' || coerceType === 'string') {
+            return val;
+        }
+        switch (coerceType) {
+            case 'boolean':
+                // a really liberal interpretation of "false" - "" "0" and "false" are false, everything else is true
+                return !!val || val.toLowerCase() !== 'false';
+            case 'number':
+                return parseInt(val, 10);
+            default:
+                throw new TypeError('Coerce type not supported');
+        }
+    }
+
+    keys(): MapIterator<string> {
+        return this.#parsed.keys();
+    }
+
+    values(): MapIterator<string> {
+        return this.#parsed.values();
+    }
+
+    [Symbol.iterator](): MapIterator<[string, string]> {
+        return this.#parsed[Symbol.iterator]();
+    }
+
+    entries() {
+        return this.#parsed.entries();
+    }
+
+    toString() {
+        return this.#connectionString;
+    }
+
+    has(key: string) {
+        return this.#parsed.has(key.toLowerCase());
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    forEach(callbackfn: (value: string, key: string, map: ReadonlyMap<string, string>) => void, thisArg?: any): void {
+        this.#parsed.forEach((value, key) => {
+            callbackfn.call(thisArg ?? this, value, key, this);
+        });
+    }
+
+    // a way to extract a formatted object from the connection string
+    toSchema<T extends SchemaDefinition>(schema: T): { [Property in keyof T]: string | number | boolean } {
+        return Object.fromEntries(Object.entries(schema).map(([key, { type, default: defaultValue, aliases }]) => {
+            // try to find the property
+            const prop = [key, ...aliases ?? []].find((k) => this.has(k));
+            return [key, prop ? this.get(prop, type) : defaultValue];
+        }));
+    }
+}
+
+export default function parse(connectionString: string) {
+    return Object.freeze(new ConnectionString(connectionString));
+}
