locality-idb 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,741 @@
+
+//#region node_modules/.pnpm/nhb-toolbox@4.28.66/node_modules/nhb-toolbox/dist/esm/guards/primitives.js
+function isNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isInteger(value) {
+	return isNumber(value) && Number.isInteger(value);
+}
+function isPositiveInteger(value) {
+	return isInteger(value) && value > 0;
+}
+function isBoolean(value) {
+	return typeof value === "boolean";
+}
+function isNonEmptyString(value) {
+	return isString(value) && value?.length > 0;
+}
+
+//#endregion
+//#region node_modules/.pnpm/nhb-toolbox@4.28.66/node_modules/nhb-toolbox/dist/esm/guards/non-primitives.js
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isValidArray(value) {
+	return Array.isArray(value) && value?.length > 0;
+}
+function isObject(value) {
+	return value !== null && typeof value === "object" && !isArray(value);
+}
+function isNotEmptyObject(value) {
+	return isObject(value) && Object.keys(value)?.length > 0;
+}
+function isArrayOfType(value, typeCheck) {
+	return isArray(value) && value?.every(typeCheck);
+}
+
+//#endregion
+//#region node_modules/.pnpm/nhb-toolbox@4.28.66/node_modules/nhb-toolbox/dist/esm/array/sort.js
+function naturalSort(a, b, options) {
+	const { caseInsensitive = true, localeAware = false } = options || {};
+	const _createChunks = (str) => {
+		const chunks = [];
+		let current = "";
+		let isNumeric = false;
+		for (const char of str) {
+			const charIsNum = !Number.isNaN(Number(char));
+			if (current?.length === 0) {
+				current = char;
+				isNumeric = charIsNum;
+				continue;
+			}
+			if (charIsNum === isNumeric) current += char;
+			else {
+				chunks?.push(isNumeric ? Number(current) : current);
+				current = char;
+				isNumeric = charIsNum;
+			}
+		}
+		if (current?.length > 0) chunks?.push(isNumeric ? Number(current) : current);
+		return chunks;
+	};
+	const aChunks = _createChunks(a);
+	const bChunks = _createChunks(b);
+	for (let i = 0; i < Math.min(aChunks?.length, bChunks?.length); i++) {
+		let aChunk = aChunks[i];
+		let bChunk = bChunks[i];
+		if (caseInsensitive && typeof aChunk === "string" && typeof bChunk === "string") {
+			aChunk = aChunk?.toLowerCase();
+			bChunk = bChunk?.toLowerCase();
+		}
+		if (typeof aChunk !== typeof bChunk) return typeof aChunk === "string" ? 1 : -1;
+		if (aChunk !== bChunk) {
+			if (typeof aChunk === "number" && typeof bChunk === "number") return aChunk - bChunk;
+			if (typeof aChunk === "string" && typeof bChunk === "string") {
+				if (localeAware) {
+					const cmp = aChunk.localeCompare(bChunk, void 0, { sensitivity: caseInsensitive ? "accent" : "variant" });
+					if (cmp !== 0) return cmp;
+				}
+				return aChunk < bChunk ? -1 : 1;
+			}
+		}
+	}
+	return aChunks?.length - bChunks?.length;
+}
+function sortAnArray(array, options) {
+	if (!isValidArray(array)) return array;
+	if (isArrayOfType(array, isString)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? naturalSort(b, a) : naturalSort(a, b));
+	if (isArrayOfType(array, isNumber)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? b - a : a - b);
+	if (isArrayOfType(array, isBoolean)) return [...array].sort((a, b) => options?.sortOrder === "desc" ? Number(b) - Number(a) : Number(a) - Number(b));
+	if (isArrayOfType(array, isObject) && options && "sortByField" in options) return [...array].sort((a, b) => {
+		const _getKeyValue = (obj, path) => {
+			return path.split(".").reduce((acc, key) => acc?.[key], obj);
+		};
+		const keyA = _getKeyValue(a, options?.sortByField);
+		const keyB = _getKeyValue(b, options?.sortByField);
+		if (keyA == null || keyB == null) return keyA == null ? 1 : -1;
+		if (isString(keyA) && isString(keyB)) return options?.sortOrder === "desc" ? naturalSort(keyB, keyA) : naturalSort(keyA, keyB);
+		if (isNumber(keyA) && isNumber(keyB)) return options?.sortOrder === "desc" ? keyB - keyA : keyA - keyB;
+		if (isBoolean(keyA) && isBoolean(keyB)) return options?.sortOrder === "desc" ? Number(keyB) - Number(keyA) : Number(keyA) - Number(keyB);
+		return 0;
+	});
+	return [...array];
+}
+
+//#endregion
+//#region src/core.ts
+/** Symbol key for column column data type */
+const ColumnType = Symbol("ColumnType");
+/** Symbol key for primary key marker */
+const IsPrimaryKey = Symbol("IsPrimaryKey");
+/** Symbol key for auto increment marker */
+const IsAutoInc = Symbol("IsAutoInc");
+/** Symbol key for optional marker */
+const IsOptional = Symbol("IsOptional");
+/** Symbol key for indexed marker */
+const IsIndexed = Symbol("IsIndexed");
+/** Symbol key for unique marker */
+const IsUnique = Symbol("IsUnique");
+/** Symbol key for default value */
+const DefaultValue = Symbol("DefaultValue");
+/** @class Represents a column definition. */
+var Column = class {
+	constructor(type) {
+		this[ColumnType] = type;
+	}
+	/** @instance Marks column as primary key */
+	pk() {
+		this[IsPrimaryKey] = true;
+		return this;
+	}
+	/** @instance Marks column as unique */
+	unique() {
+		this[IsIndexed] = true;
+		this[IsUnique] = true;
+		return this;
+	}
+	/** @instance Enables auto increment - only available for numeric columns */
+	auto() {
+		const colType = this[ColumnType];
+		if (!isNonEmptyString(colType) || ![
+			"int",
+			"integer",
+			"float",
+			"number"
+		].includes(colType.toLowerCase())) throw new Error(`auto() can only be used with integer columns, got: ${colType}`);
+		this[IsAutoInc] = true;
+		return this;
+	}
+	/** @instance Marks column as indexed */
+	index() {
+		this[IsIndexed] = true;
+		return this;
+	}
+	/** @instance Sets default value for the column */
+	default(value) {
+		this[DefaultValue] = value;
+		return this;
+	}
+	/** @instance Marks column as optional */
+	optional() {
+		this[IsOptional] = true;
+		return this;
+	}
+};
+/** @class Represents a table. */
+var Table = class {
+	name;
+	columns;
+	constructor(name, columns) {
+		this.name = name;
+		this.columns = columns;
+	}
+};
+
+//#endregion
+//#region src/factory.ts
+/**
+* * Opens an IndexedDB database with the specified stores.
+* @param name Database name
+* @param stores Array of store configurations
+* @param version Database version (default is `1`)
+* @returns Promise that resolves to the opened {@link IDBDatabase} instance.
+*/
+function openDBWithStores(name, stores, version = 1) {
+	return new Promise((resolve, reject) => {
+		if (!window.indexedDB) throw new Error("IndexedDb is not supported in this environment or browser!");
+		const request = window.indexedDB.open(name, version);
+		request.onupgradeneeded = (event) => {
+			const db = event.target.result;
+			for (const store of stores) if (!db.objectStoreNames.contains(store.name)) db.createObjectStore(store.name, {
+				keyPath: store.keyPath,
+				autoIncrement: store.autoIncrement
+			});
+		};
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+
+//#endregion
+//#region src/helpers.ts
+/** Ensure UUID variant is RFC4122 compliant */
+function _hexVariant(hex) {
+	return (parseInt(hex, 16) & 63 | 128).toString(16).padStart(2, "0");
+}
+/** Convert a hex string to UUID format */
+function _formatUUID(h, v, up) {
+	const part3 = String(v) + h.slice(13, 16);
+	const part4 = _hexVariant(h.slice(16, 18)) + h.slice(18, 20);
+	const formatted = [
+		h.slice(0, 8),
+		h.slice(8, 12),
+		part3,
+		part4,
+		h.slice(20, 32)
+	].join("-");
+	return up ? formatted.toUpperCase() : formatted;
+}
+
+//#endregion
+//#region src/utils.ts
+/**
+* * Generate a random UUID v4 string
+* @param uppercase Whether to return the UUID in uppercase format. Default is `false`.
+* @returns UUID v4 string
+*/
+function uuidV4(uppercase = false) {
+	const bytes = new Uint8Array(16);
+	for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+	let hex = "";
+	for (let i = 0; i < 16; i++) hex += bytes[i].toString(16).padStart(2, "0");
+	return _formatUUID(hex, 4, uppercase);
+}
+/**
+* * Get current timestamp in ISO 8601 format
+* @param date Optional Date object to format. Defaults to current {@link Date new Date()}
+* @return Timestamp string in ISO 8601 format
+*/
+function getTimestamp(date = /* @__PURE__ */ new Date()) {
+	return date.toISOString();
+}
+
+//#endregion
+//#region src/query.ts
+/** Symbol for type extraction (exists only in type system) */
+const Selected = Symbol("Selected");
+/** Symbol to indicate if insert data is array */
+const IsArray = Symbol("IsArray");
+/**
+* @class Select query builder.
+*/
+var SelectQuery = class {
+	#table;
+	#readyPromise;
+	#dbGetter;
+	#whereCondition;
+	#orderByKey;
+	#orderByDir = "asc";
+	#limitCount;
+	constructor(table, dbGetter, readyPromise) {
+		this.#table = table;
+		this.#dbGetter = dbGetter;
+		this.#readyPromise = readyPromise;
+	}
+	/**
+	* @instance Select or exclude specific columns
+	* @param cols Columns to select or exclude
+	*/
+	select(cols) {
+		this[Selected] = cols;
+		return this;
+	}
+	/**
+	* @instance  Filter rows based on predicate function
+	* @param predicate Filtering function
+	*/
+	where(predicate) {
+		this.#whereCondition = predicate;
+		return this;
+	}
+	/**
+	* @instance  Order results by specified key and direction
+	* @param key Key to order by
+	* @param dir Direction: 'asc' | 'desc' (default: 'asc')
+	*/
+	orderBy(key, dir = "asc") {
+		this.#orderByKey = key;
+		this.#orderByDir = dir;
+		return this;
+	}
+	/**
+	* @instance Limit number of results
+	* @param count Maximum number of results to return
+	*/
+	limit(count) {
+		this.#limitCount = count;
+		return this;
+	}
+	/** Projects a row based on selected fields */
+	#projectRow(row) {
+		if (!isNotEmptyObject(this[Selected])) return row;
+		const projected = {};
+		const selectionEntries = Object.entries(this[Selected]);
+		const selectionKeys = new Set(Object.keys(this[Selected]));
+		if (selectionEntries.some(([, value]) => value === true)) {
+			for (const [key, value] of selectionEntries) if (value === true) projected[key] = row[key];
+		} else for (const key of Object.keys(row)) if (!selectionKeys.has(key) || this[Selected][key] !== false) projected[key] = row[key];
+		return projected;
+	}
+	async all() {
+		await this.#readyPromise;
+		return new Promise((resolve, reject) => {
+			const request = this.#dbGetter().transaction(this.#table, "readonly").objectStore(this.#table).getAll();
+			request.onsuccess = () => {
+				let results = request.result;
+				if (this.#whereCondition) results = results.filter(this.#whereCondition);
+				if (this.#orderByKey) results = sortAnArray(results, {
+					sortOrder: this.#orderByDir,
+					sortByField: this.#orderByKey
+				});
+				if (this.#limitCount) results = results.slice(0, this.#limitCount);
+				resolve(results.map((row) => this.#projectRow(row)));
+			};
+			request.onerror = () => reject(request.error);
+		});
+	}
+	async first() {
+		await this.#readyPromise;
+		return new Promise((resolve, reject) => {
+			const request = this.#dbGetter().transaction(this.#table, "readonly").objectStore(this.#table).getAll();
+			request.onsuccess = () => {
+				let results = request.result;
+				if (this.#whereCondition) results = results.filter(this.#whereCondition);
+				if (results.length > 0) resolve(this.#projectRow(results[0]));
+				else resolve(null);
+			};
+			request.onerror = () => reject(request.error);
+		});
+	}
+};
+/** @class Insert query builder. */
+var InsertQuery = class {
+	#table;
+	#dbGetter;
+	#readyPromise;
+	#dataToInsert = [];
+	#columns;
+	constructor(table, dbGetter, readyPromise, columns) {
+		this.#table = table;
+		this.#dbGetter = dbGetter;
+		this.#readyPromise = readyPromise;
+		this.#columns = columns;
+	}
+	/**
+	* @instance Sets the data to be inserted
+	* @param data Data object or array of data objects to insert
+	*/
+	values(data) {
+		this[IsArray] = Array.isArray(data);
+		this.#dataToInsert = this[IsArray] ? data : [data];
+		return this;
+	}
+	/**
+	* @instance Executes the insert query
+	* @returns Inserted record(s)
+	*/
+	async run() {
+		await this.#readyPromise;
+		return new Promise((resolve, reject) => {
+			const transaction = this.#dbGetter().transaction(this.#table, "readwrite");
+			const store = transaction.objectStore(this.#table);
+			const insertedDocs = [];
+			const promises = this.#dataToInsert.map((data) => {
+				return new Promise((res, rej) => {
+					const updated = { ...data };
+					if (this.#columns) Object.entries(this.#columns).forEach(([fieldName, column]) => {
+						const defaultValue = column[DefaultValue];
+						if (!(fieldName in updated) && defaultValue !== void 0) updated[fieldName] = defaultValue;
+						const columnType = column[ColumnType];
+						if (columnType === "uuid" && !(fieldName in updated)) updated[fieldName] = uuidV4();
+						if (columnType === "timestamp" && !(fieldName in updated)) updated[fieldName] = getTimestamp();
+					});
+					const request = store.add(updated);
+					request.onsuccess = () => {
+						const key = request.result;
+						const getRequest = store.get(key);
+						getRequest.onsuccess = () => {
+							insertedDocs.push(getRequest.result);
+							res();
+						};
+						getRequest.onerror = () => rej(getRequest.error);
+					};
+					request.onerror = () => rej(request.error);
+				});
+			});
+			transaction.oncomplete = () => Promise.all(promises).then(() => this[IsArray] === true ? resolve(insertedDocs) : resolve(insertedDocs[0])).catch(reject);
+			transaction.onerror = () => reject(transaction.error);
+		});
+	}
+};
+/** @class Update query builder. */
+var UpdateQuery = class {
+	#table;
+	#dbGetter;
+	#readyPromise;
+	#dataToUpdate;
+	#whereCondition;
+	constructor(table, dbGetter, readyPromise) {
+		this.#table = table;
+		this.#dbGetter = dbGetter;
+		this.#readyPromise = readyPromise;
+	}
+	/**
+	* @instance Sets the data to be updated
+	* @param values Values to update
+	*/
+	set(values) {
+		this.#dataToUpdate = values;
+		return this;
+	}
+	/**
+	* @instance Filter rows to update
+	* @param predicate Filtering function
+	*/
+	where(predicate) {
+		this.#whereCondition = predicate;
+		return this;
+	}
+	/**
+	* @instance Executes the update query
+	* @returns Number of records updated
+	*/
+	async run() {
+		await this.#readyPromise;
+		if (!isNotEmptyObject(this.#dataToUpdate)) throw new Error("No values set for update!");
+		return new Promise((resolve, reject) => {
+			const store = this.#dbGetter().transaction(this.#table, "readwrite").objectStore(this.#table);
+			const request = store.getAll();
+			let updateCount = 0;
+			request.onsuccess = () => {
+				let rows = request.result;
+				if (this.#whereCondition) rows = rows.filter(this.#whereCondition);
+				const updatePromises = rows.map((row) => {
+					return new Promise((res, rej) => {
+						const updatedRow = {
+							...row,
+							...this.#dataToUpdate
+						};
+						const putRequest = store.put(updatedRow);
+						putRequest.onsuccess = () => {
+							updateCount++;
+							res();
+						};
+						putRequest.onerror = () => rej(putRequest.error);
+					});
+				});
+				Promise.all(updatePromises).then(() => resolve(updateCount)).catch(reject);
+			};
+			request.onerror = () => reject(request.error);
+		});
+	}
+};
+/** @class Delete query builder. */
+var DeleteQuery = class {
+	#table;
+	#dbGetter;
+	#readyPromise;
+	#keyField;
+	#whereCondition;
+	constructor(table, dbGetter, readyPromise, keyField) {
+		this.#table = table;
+		this.#dbGetter = dbGetter;
+		this.#readyPromise = readyPromise;
+		this.#keyField = keyField;
+	}
+	/**
+	* @instance Filter rows to delete
+	* @param predicate Filtering function
+	*/
+	where(predicate) {
+		this.#whereCondition = predicate;
+		return this;
+	}
+	/**
+	* @instance Executes the delete query
+	* @returns Number of records deleted
+	*/
+	async run() {
+		await this.#readyPromise;
+		return new Promise((resolve, reject) => {
+			const store = this.#dbGetter().transaction(this.#table, "readwrite").objectStore(this.#table);
+			const request = store.getAll();
+			let deleteCount = 0;
+			request.onsuccess = () => {
+				let rows = request.result;
+				if (this.#whereCondition) rows = rows.filter(this.#whereCondition);
+				const deletePromises = rows.map((row) => {
+					return new Promise((res, rej) => {
+						const key = row[this.#keyField];
+						const delRequest = store.delete(key);
+						delRequest.onsuccess = () => {
+							deleteCount++;
+							res();
+						};
+						delRequest.onerror = () => rej(delRequest.error);
+					});
+				});
+				Promise.all(deletePromises).then(() => resolve(deleteCount)).catch(reject);
+			};
+			request.onerror = () => reject(request.error);
+		});
+	}
+};
+
+//#endregion
+//#region src/client.ts
+/**
+* @class `Locality` class for {@link IndexedDB} interactions.
+*
+* @example
+* import { column, defineSchema, Locality } from 'locality-idb';
+*
+* const schema = defineSchema({
+*   users: {
+*     id: column.int().pk().auto(),
+*     name: column.text(),
+*     email: column.text().unique(),
+*   },
+* });
+*
+* const db = new Locality({
+*   dbName: 'my-database',
+*   version: 1,
+*   schema,
+* });
+*
+* // Optional
+* await db.ready();
+*
+* // Insert a new user
+* const inserted = await db.insert('users').values({ name: 'Alice', email: 'alice@wonderland.mad' }).run();
+*
+* // Get all users
+* const allUsers = await db.from('users').all();
+*
+* // Select users
+* const allAlices = await db.from('users').where((user) => user.email.includes('alice')).all();
+*
+* // Update a user
+* const updated = await db.update('users').set({ name: 'Alice Liddell' }).where((user) => user.id === 1).run();
+*
+* // Delete a user
+* const deleted = await db.delete('users').where((user) => user.id === 1).run();
+*/
+var Locality = class {
+	#name;
+	#schema;
+	#version;
+	#db;
+	#readyPromise;
+	constructor(config) {
+		this.#name = config.dbName;
+		this.#schema = config.schema;
+		this.#version = config.version;
+		const store = this.#buildStoresConfig();
+		this.#readyPromise = openDBWithStores(this.#name, store, this.#version).then((db) => {
+			this.#db = db;
+		});
+	}
+	/** Build store configurations from schema. */
+	#buildStoresConfig() {
+		return Object.entries(this.#schema).map(([tableName, table]) => {
+			const columns = table.columns;
+			const autoInc = Object.values(columns).find((col) => col[IsPrimaryKey])?.[IsAutoInc] || false;
+			return {
+				name: tableName,
+				keyPath: Object.entries(columns).find(([_, col]) => col[IsPrimaryKey])?.[0],
+				autoIncrement: autoInc
+			};
+		});
+	}
+	/** @instance Waits for database initialization to complete. */
+	async ready() {
+		return this.#readyPromise;
+	}
+	/**
+	* @instance Select records from a table.
+	* @param table Table name.
+	* @returns
+	*/
+	from(table) {
+		return new SelectQuery(table, () => this.#db, this.#readyPromise);
+	}
+	/**
+	* @instance Insert records into a table.
+	* @param table Table name.
+	*/
+	insert(table) {
+		return new InsertQuery(table, () => this.#db, this.#readyPromise, this.#schema[table].columns);
+	}
+	/**
+	* @instance Update records in a table.
+	* @param table Table name.
+	*/
+	update(table) {
+		return new UpdateQuery(table, () => this.#db, this.#readyPromise);
+	}
+	/**
+	* @instance Delete records from a table.
+	* @param table Table name.
+	*/
+	delete(table) {
+		const columns = this.#schema[table].columns;
+		const keyField = Object.entries(columns).find(([_, col]) => col[IsPrimaryKey])?.[0];
+		return new DeleteQuery(table, () => this.#db, this.#readyPromise, keyField);
+	}
+};
+
+//#endregion
+//#region src/schema.ts
+/**
+* * Defines a database schema from a given schema definition.
+* @param schema An object defining the schema, where each key is a table name and each value is a record of {@link column} definitions.
+* @returns An object mapping each table name to its corresponding {@link Table} instance.
+*
+* @example
+* const schema = defineSchema({
+*   users: {
+*     id: column.int().pk().auto(),
+*     name: column.varchar(255).unique(),
+*     createdAt: column.timestamp(),
+*     isActive: column.bool().default(true),
+*   },
+*   posts: {
+*     id: column.int().pk().auto(),
+*     userId: column.int().index(),
+*     title: column.varchar(255),
+*     content: column.text(),
+*     createdAt: column.timestamp(),
+*   },
+* });
+*
+* // Infer types:
+*
+* type User = InferSelectType<typeof schema.users>;
+* type InsertUser = InferInsertType<typeof schema.users>;
+* type UpdateUser = InferUpdateType<typeof schema.users>;
+*
+* type Post = InferSelectType<typeof schema.posts>;
+* type InsertPost = InferInsertType<typeof schema.posts>;
+* type UpdatePost = InferUpdateType<typeof schema.posts>;
+*/
+function defineSchema(schema) {
+	const result = {};
+	for (const [tableName, columns] of Object.entries(schema)) result[tableName] = new Table(tableName, columns);
+	return result;
+}
+/**
+* * Factory function to create a new {@link Table} instance.
+* @param name The name of the table.
+* @param columns An object defining the columns of the table using {@link column} definitions.
+* @returns A new {@link Table} instance representing the table schema.
+*
+* @example
+* const userTable = table('users', {
+*   id: column.int().pk().auto(),
+*   name: column.varchar(255).unique(),
+*   createdAt: column.timestamp(),
+*   isActive: column.bool().default(true),
+* });
+*/
+function table(name, columns) {
+	return new Table(name, columns);
+}
+/**
+* * Column factory with various column types.
+*
+* @remarks
+* - `char` and `varchar` accept an optional length parameter.
+* - `object`, `array`, `list`, `tuple`, `set`, and `map` are generic and can be typed.
+* - `custom` can be used for any custom data type.
+* - Each column can be further configured using methods like `pk()`, `unique()`, `auto()`, `index()`, `default()`, and `optional()`.
+* - Example usage is provided below:
+*
+* @example
+* const idColumn = column.int().pk().auto();
+* const nameColumn = column.varchar(255).unique();
+* const createdAtColumn = column.timestamp();
+* const isActiveColumn = column.bool().default(true);
+*
+* // Define a table schema
+* const userTable = table('users', {
+*   id: idColumn,
+*   name: nameColumn,
+*   createdAt: createdAtColumn,
+*   isActive: isActiveColumn,
+* });
+*
+* // Define a database schema
+* const schema = defineSchema({
+*   users: {
+*       id: idColumn,
+*       name: nameColumn,
+*       createdAt: createdAtColumn,
+*       isActive: isActiveColumn,
+*   },
+* });
+*/
+const column = {
+	int: () => new Column("int"),
+	float: () => new Column("float"),
+	number: () => new Column("number"),
+	bigint: () => new Column("bigint"),
+	text: () => new Column("text"),
+	string: () => new Column("string"),
+	char: (l) => new Column(`char(${isPositiveInteger(l) ? l : "0"})`),
+	varchar: (l) => new Column(`varchar(${isPositiveInteger(l) ? l : "0"})`),
+	uuid: () => new Column("uuid"),
+	timestamp: () => new Column("timestamp"),
+	bool: () => new Column("bool"),
+	date: () => new Column("date"),
+	object: () => new Column(`object`),
+	array: () => new Column(`array`),
+	list: () => new Column(`list`),
+	tuple: () => new Column(`tuple`),
+	set: () => new Column(`set`),
+	map: () => new Column(`map`),
+	custom: () => new Column(`custom`)
+};
+
+//#endregion
+exports.Locality = Locality;
+exports.column = column;
+exports.defineSchema = defineSchema;
+exports.getTimestamp = getTimestamp;
+exports.openDBWithStores = openDBWithStores;
+exports.table = table;
+exports.uuidV4 = uuidV4;