kysely-rizzolver 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yariv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# Kysely Rizzolver
+
+Complex Kysely queries, maximum rizz, type-safe every time.
+
+## Overview
+
+Kysely Rizzolver is a utility library for building complex, type-safe queries.
+
+There are already a bunch of [awesome
+tools](https://github.com/kysely-org/awesome-kysely) for working with Kysely out
+there, but none strike the balance I'm looking for:
+- [kysely-orm](https://github.com/seeeden/kysely-orm) is a full-fledged ORM.
+  It's a really cool project, but like all ORMs it works until it doesn't. If
+  you need fine control over your queries, it gets very cumbersome.
+- [kysely-mapper](https://github.com/jtlapp/kysely-mapper) is a bit more
+  lightweight than an ORM, but it still wraps Kysely with a "hatch" to an
+  underlying Kysely instance. It is also quite verbose and rigid in my opinion.
+
+Kysely Rizzolver in constast, works *with* Kysely. It does not replace, wrap,
+abstract or hide it and can be incrementally added to an existing Kysely
+project.
+
+## Installation
+
+You can install it via npm:
+
+```sh
+npm install kysely-rizzolver
+```
+
+## Usage
+
+### Creating a KyselyRizzolver
+
+`KyselyRizzolver` is the heart of Kysely Rizzolver. It is a definition of the
+table names and columns in your database.
+
+```typescript
+import { KyselyRizzolver } from 'kysely-rizzolver';
+
+const rizzolver = KyselyRizzolver.builderNoSchema()
+    .table('user', ['id', 'name', 'email'] as const)
+    .table('post', ['id', 'title', 'content', 'authorId'] as const)
+    .build();
+```
+
+or if you have a schema, for example from [kysely-codegen](https://github.com/RobinBlomberg/kysely-codegen), you can use it like this:
+
+```typescript
+import { KyselyRizzolver } from 'kysely-rizzolver';
+import { DB } from './db-types-generated';
+
+const rizzolver = KyselyRizzolver.builderForSchema<DB>()
+    .table('user', ['id', 'name', 'email'] as const)
+    .table('post', ['id', 'title', 'content', 'authorId'] as const)
+    .build();
+```
+
+You will get compile time errors if the fields don't actually match the schema.
+
+### Creating a Query Builder
+
+```typescript
+import { rizzolver } from './rizzolver';
+
+const qb = await rizzolver
+    .newQueryBuilder()
+    .add('session', 's')
+    .add('user', 'u')
+    .add('image', 'i');
+```
+
+The query builder exposes expressions to use in queries. For example:
+
+- `qb.table('u')` returns `'user as u'`.
+- `qb.fieldsOf('u')` returns `['u.id as _u_id', 'u.name as _u_name', 'u.email as _u_email']`.
+- `qb.field('u.name').value` returns `'_u_name'`.
+- `qb.field('u.name').from('a')` returns `'a._u_name'`.
+
+### Using a Query Builder
+
+For example, we can use the query builder above to fetch for each session the
+user it is associated with and their avatar image if it exists:
+
+```typescript
+const rows = await db
+    .selectFrom(qb.table('s'))
+    .innerJoin(
+        (eb) =>
+            eb
+                .selectFrom(qb.table('u'))
+                .leftJoin(qb.table('i'), 'u.avatar_image_id', 'i.id')
+                .select(qb.fieldsOf('u', 'i'))
+                .as('a'),
+        (join) => join.onRef('s.user_id', '=', `'a._u_id'`)
+    )
+    .select(qb.fieldsOf('s'))
+    .selectAll('a')
+    .where('s.id', '=', sessionId)
+    .execute();
+```
+
+Note that Kysely remains as the main driver of the query. This makes it easy to
+incrementally switch to Kysely Rizzolver.
+
+### Parsing the Results
+
+The fetched rows can be parsed into type-safe objects using the same query
+builder that was used to create the query, as such:
+
+```typescript
+const results = await qb.run(rows);
+
+// To get the user model
+const first = results.first?.selectors.u;
+
+// To get the first user's avatar image url
+const avatarUrl = results.first?.selectors.i?.url;
+
+// To collect all avatar image urls
+const avatarUrls = results.rows.map((row) => row.selectors.i?.url);
+```
+
+To make it easier to work with the results and pass them around, accept them as
+parameters in other functions, etc., you can further process the results into a
+`FetchResult`:
+
+```typescript
+// Fetches the first user, or returns undefined if there are no results.
+const maybeOneUser = results.newFetchOneResult('u');
+
+// Fetches the first user, and throws an error if there are no results.
+const oneUser = results.newFetchOneXResult('u');
+
+// Fetches all users. May return an empty array if there are no results.
+const someUsers = results.newFetchSomeResult('u');
+```
+
+Play around with the query builder and the results to get a feel for how they
+work.
+
+Everything is type-safe end to end.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](./LICENSE)
+file for details.

package/dist/cjs/fetch-result-factory.d.ts

@@ -0,0 +1,52 @@
+import type { Selectable } from 'kysely';
+import { type FetchOneResult, type FetchOneXResult, type FetchSomeResult } from './fetch-result.js';
+import { type ModelCollection } from './model-collection.js';
+/**
+ * A {@link FetchResultFactory} exposes variants of fetch-related functions, but
+ * with the `DB` type parameter already set.
+ *
+ * This makes it less verbose to work with fetch results in a type-safe way.
+ */
+export type FetchResultFactory<DB> = ReturnType<typeof newFetchResultFactory<DB>>;
+export declare function newFetchResultFactory<DB>(): {
+    /**
+     * Creates a new {@link FetchOneResult} instance.
+     */
+    newFetchOne<K extends keyof DB & string>(table: K, result: Selectable<DB[K]> | undefined, models?: ModelCollection<DB>): FetchOneResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Creates a new {@link FetchOneXResult} instance.
+     *
+     * Note: it may be counterintuitive, but this function accepts `undefined` as
+     * input. I found it is way more convenient to assert the type once in this
+     * funciton rather than in every caller.
+     */
+    newFetchOneX<K extends keyof DB & string>(table: K, result: Selectable<DB[K]> | undefined, models?: ModelCollection<DB>): FetchOneXResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Creates a new {@link FetchSomeResult} instance.
+     */
+    newFetchSome<K extends keyof DB & string>(table: K, result: Selectable<DB[K]>[], models?: ModelCollection<DB>): FetchSomeResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Checks if a {@link FetchResult} is a {@link FetchOneResult}.
+     */
+    isFetchOne<K extends keyof DB & string>(table: K, result: unknown): result is FetchOneResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Checks if a {@link FetchResult} is a {@link FetchOneXResult}.
+     */
+    isFetchOneX<K extends keyof DB & string>(table: K, result: unknown): result is FetchOneXResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Checks if a {@link FetchResult} is a {@link FetchSomeResult}.
+     */
+    isFetchSome<K extends keyof DB & string>(table: K, result: unknown): result is FetchSomeResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Asserts that a {@link FetchResult} is a {@link FetchOneResult}.
+     */
+    assertIsFetchOne<K extends keyof DB & string>(table: K, result: unknown): asserts result is FetchOneResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Asserts that a {@link FetchResult} is a {@link FetchOneXResult}.
+     */
+    assertIsFetchOneX<K extends keyof DB & string>(table: K, result: unknown): asserts result is FetchOneXResult<DB, K, Selectable<DB[K]>>;
+    /**
+     * Asserts that a {@link FetchResult} is a {@link FetchSomeResult}.
+     */
+    assertIsFetchSome<K extends keyof DB & string>(table: K, result: unknown): asserts result is FetchSomeResult<DB, K, Selectable<DB[K]>>;
+};

package/dist/cjs/fetch-result-factory.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newFetchResultFactory = newFetchResultFactory;
+const fetch_result_js_1 = require("./fetch-result.js");
+const model_collection_js_1 = require("./model-collection.js");
+function newFetchResultFactory() {
+    return {
+        /**
+         * Creates a new {@link FetchOneResult} instance.
+         */
+        newFetchOne(table, result, models) {
+            models ??= (0, model_collection_js_1.newModelCollection)();
+            if (result) {
+                models.add(table, result);
+            }
+            return (0, fetch_result_js_1.newFetchOneResult)(table, result, models);
+        },
+        /**
+         * Creates a new {@link FetchOneXResult} instance.
+         *
+         * Note: it may be counterintuitive, but this function accepts `undefined` as
+         * input. I found it is way more convenient to assert the type once in this
+         * funciton rather than in every caller.
+         */
+        newFetchOneX(table, result, models) {
+            models ??= (0, model_collection_js_1.newModelCollection)();
+            if (result) {
+                models.add(table, result);
+            }
+            return (0, fetch_result_js_1.newFetchOneXResult)(table, result, models);
+        },
+        /**
+         * Creates a new {@link FetchSomeResult} instance.
+         */
+        newFetchSome(table, result, models) {
+            models ??= (0, model_collection_js_1.newModelCollection)();
+            for (const item of result) {
+                models.add(table, item);
+            }
+            return (0, fetch_result_js_1.newFetchSomeResult)(table, result, models);
+        },
+        /**
+         * Checks if a {@link FetchResult} is a {@link FetchOneResult}.
+         */
+        isFetchOne(table, result) {
+            return (0, fetch_result_js_1.isFetchOneResult)(result) && result.table === table;
+        },
+        /**
+         * Checks if a {@link FetchResult} is a {@link FetchOneXResult}.
+         */
+        isFetchOneX(table, result) {
+            return (0, fetch_result_js_1.isFetchOneXResult)(result) && result.table === table;
+        },
+        /**
+         * Checks if a {@link FetchResult} is a {@link FetchSomeResult}.
+         */
+        isFetchSome(table, result) {
+            return (0, fetch_result_js_1.isFetchSomeResult)(result) && result.table === table;
+        },
+        /**
+         * Asserts that a {@link FetchResult} is a {@link FetchOneResult}.
+         */
+        assertIsFetchOne(table, result) {
+            (0, fetch_result_js_1.assertIsFetchOneResult)(result);
+            if (result.table !== table) {
+                throw new Error(`Expected a fetchOne result for table ${table}`);
+            }
+        },
+        /**
+         * Asserts that a {@link FetchResult} is a {@link FetchOneXResult}.
+         */
+        assertIsFetchOneX(table, result) {
+            (0, fetch_result_js_1.assertIsFetchOneXResult)(result);
+            if (result.table !== table) {
+                throw new Error(`Expected a fetchOne result with a non-null non for table ${table}`);
+            }
+        },
+        /**
+         * Asserts that a {@link FetchResult} is a {@link FetchSomeResult}.
+         */
+        assertIsFetchSome(table, result) {
+            (0, fetch_result_js_1.assertIsFetchSomeResult)(result);
+            if (result.table !== table) {
+                throw new Error(`Expected a fetchSome result for table ${table}`);
+            }
+        }
+    };
+}

package/dist/cjs/fetch-result.d.ts

@@ -0,0 +1,111 @@
+import type { Selectable } from 'kysely';
+import type { ModelCollection } from './model-collection.js';
+/**
+ * A {@link FetchResult} is a result of a fetch operation. It can be one of
+ * three types:
+ * - {@link FetchOneResult} - A result of a fetch operation that is expected to
+ *   return up to one row,
+ * - {@link FetchOneXResult} - A result of a fetch operation that is expected to
+ *   return exactly one row,
+ * - {@link FetchSomeResult} - A result of a fetch operation that is expected to
+ *   return any number of rows.
+ */
+export type FetchResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>> = FetchOneResult<DB, T, R> | FetchOneXResult<DB, T, R> | FetchSomeResult<DB, T, R>;
+/**
+ * A {@link FetchOneResult} is a result of a fetch operation that is expected to
+ * return up to one row.
+ */
+export type FetchOneResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>> | undefined> = {
+    fetchType: 'fetchOne';
+    table: T;
+    result: R | undefined;
+    models?: ModelCollection<DB>;
+    /**
+     * Returns this result as a {@link FetchOneXResult}.
+     *
+     * @throws If the result is null or undefined.
+     */
+    asFetchOneX(): FetchOneXResult<DB, T, R & {}>;
+};
+/**
+ * A {@link FetchOneXResult} is a result of a fetch operation that is expected
+ * to return exactly one row.
+ */
+export type FetchOneXResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>> = {
+    fetchType: 'fetchOne';
+    table: T;
+    result: R;
+    models?: ModelCollection<DB>;
+    /**
+     * Returns self. This is a no-op, but it's here to make it possible to
+     * cast this object back to a {@link FetchOneXResult}.
+     */
+    asFetchOneX(): FetchOneXResult<DB, T, R>;
+};
+/**
+ * A {@link FetchSomeResult} is a result of a fetch operation that is expected
+ * to return any number of rows.
+ */
+export type FetchSomeResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>> = {
+    fetchType: 'fetchSome';
+    table: T;
+    result: R[];
+    models?: ModelCollection<DB>;
+};
+/**
+ * Used to type juggle between {@link FetchResult} and its subtypes.
+ */
+export type AsFetchOneResult<T extends FetchResult<any, string, Selectable<any>>> = T extends FetchResult<infer DB, infer T, infer R> ? FetchOneResult<DB, T, R> : never;
+/**
+ * Used to type juggle between {@link FetchResult} and its subtypes.
+ */
+export type AsFetchOneXResult<T extends FetchResult<any, string, Selectable<any>>> = T extends FetchResult<infer DB, infer T, infer R> ? FetchOneXResult<DB, T, R> : never;
+/**
+ * Used to type juggle between {@link FetchResult} and its subtypes.
+ */
+export type AsFetchSomeResult<T extends FetchResult<any, string, Selectable<any>>> = T extends FetchResult<infer DB, infer T, infer R> ? FetchSomeResult<DB, T, R> : never;
+/**
+ * Creates a new {@link FetchOneResult} instance.
+ */
+export declare function newFetchOneResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>>(table: T, result: R | undefined, models?: ModelCollection<DB>): FetchOneResult<DB, T, R>;
+/**
+ * Creates a new {@link FetchOneXResult} instance.
+ *
+ * Note: it may be counterintuitive, but this function accepts `undefined` as
+ * input. I found it is way more convenient to assert the type once in this
+ * funciton rather than in every caller.
+ */
+export declare function newFetchOneXResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>>(table: T, result: R | undefined, models?: ModelCollection<DB>): FetchOneXResult<DB, T, R>;
+/**
+ * Creates a new {@link FetchSomeResult} instance.
+ */
+export declare function newFetchSomeResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>>(table: T, result: R[], models?: ModelCollection<DB>): FetchSomeResult<DB, T, R>;
+export declare function isFetchResult(result: unknown): result is FetchResult<any, any, any>;
+/**
+ * Checks if `value` is a {@link FetchOneResult}.
+ */
+export declare function isFetchOneResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>>(value: FetchOneResult<DB, T, R> | FetchOneXResult<DB, T, R>): value is typeof value;
+export declare function isFetchOneResult(value: unknown): value is FetchOneResult<any, string, Selectable<any>>;
+/**
+ * Checks if `value` is a {@link FetchOneXResult}.
+ */
+export declare function isFetchOneXResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>>(value: FetchOneResult<DB, T, R>): value is FetchOneXResult<DB, T, R>;
+export declare function isFetchOneXResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>>(value: FetchOneXResult<DB, T, R>): value is typeof value;
+export declare function isFetchOneXResult(value: unknown): value is FetchOneXResult<any, string, Selectable<any>>;
+/**
+ * Checks if `value` is a {@link FetchSomeResult}.
+ */
+export declare function isFetchSomeResult<DB, T extends keyof DB & string, R extends Partial<Selectable<DB[T]>>>(value: FetchSomeResult<DB, T, R>): value is typeof value;
+export declare function isFetchSomeResult(value: unknown): value is FetchSomeResult<any, string, Selectable<any>>;
+/**
+ * Asserts that `value` is a {@link FetchOneResult}.
+ */
+export declare function assertIsFetchOneResult(value: unknown): asserts value is FetchOneResult<any, string, Selectable<any>>;
+/**
+ * Asserts that `value` is a {@link FetchOneXResult}.
+ */
+export declare function assertIsFetchOneXResult(value: unknown): asserts value is FetchOneXResult<any, string, Selectable<any>>;
+/**
+ * Asserts that `value` is a {@link FetchSomeResult}.
+ */
+export declare function assertIsFetchSomeResult(value: unknown): asserts value is FetchSomeResult<any, string, Selectable<any>>;

package/dist/cjs/fetch-result.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newFetchOneResult = newFetchOneResult;
+exports.newFetchOneXResult = newFetchOneXResult;
+exports.newFetchSomeResult = newFetchSomeResult;
+exports.isFetchResult = isFetchResult;
+exports.isFetchOneResult = isFetchOneResult;
+exports.isFetchOneXResult = isFetchOneXResult;
+exports.isFetchSomeResult = isFetchSomeResult;
+exports.assertIsFetchOneResult = assertIsFetchOneResult;
+exports.assertIsFetchOneXResult = assertIsFetchOneXResult;
+exports.assertIsFetchSomeResult = assertIsFetchSomeResult;
+/**
+ * Creates a new {@link FetchOneResult} instance.
+ */
+function newFetchOneResult(table, result, models) {
+    const ref = { value: null };
+    const me = {
+        fetchType: 'fetchOne',
+        table,
+        result,
+        models,
+        asFetchOneX() {
+            if (!me.result) {
+                throw new Error('Expected a fetchOneX result');
+            }
+            return ref.value;
+        }
+    };
+    ref.value = me;
+    return me;
+}
+/**
+ * Creates a new {@link FetchOneXResult} instance.
+ *
+ * Note: it may be counterintuitive, but this function accepts `undefined` as
+ * input. I found it is way more convenient to assert the type once in this
+ * funciton rather than in every caller.
+ */
+function newFetchOneXResult(table, result, models) {
+    if (!result) {
+        throw new Error('Expected a fetchOneX result');
+    }
+    const ref = { value: null };
+    const me = {
+        fetchType: 'fetchOne',
+        table,
+        result,
+        models,
+        asFetchOneX() {
+            return ref.value;
+        }
+    };
+    ref.value = me;
+    return me;
+}
+/**
+ * Creates a new {@link FetchSomeResult} instance.
+ */
+function newFetchSomeResult(table, result, models) {
+    return {
+        fetchType: 'fetchSome',
+        table,
+        result,
+        models
+    };
+}
+function isFetchResult(result) {
+    return (!!result &&
+        typeof result === 'object' &&
+        'fetchType' in result &&
+        !!result.fetchType &&
+        typeof result.fetchType === 'string' &&
+        'table' in result &&
+        !!result.table &&
+        typeof result.table === 'string' &&
+        'result' in result &&
+        (result.result === undefined ||
+            typeof result.result === 'object' ||
+            (Array.isArray(result.result) && result.result.every((r) => !!r && typeof r === 'object'))));
+}
+function isFetchOneResult(value) {
+    return isFetchResult(value) && value.fetchType === 'fetchOne' && !Array.isArray(value.result);
+}
+function isFetchOneXResult(value) {
+    return (isFetchResult(value) &&
+        value.fetchType === 'fetchOne' &&
+        !Array.isArray(value.result) &&
+        !!value.result);
+}
+function isFetchSomeResult(value) {
+    return isFetchResult(value) && value.fetchType === 'fetchSome' && Array.isArray(value.result);
+}
+/**
+ * Asserts that `value` is a {@link FetchOneResult}.
+ */
+function assertIsFetchOneResult(value) {
+    if (!isFetchOneResult(value)) {
+        throw new Error('Expected a fetchOne result');
+    }
+}
+/**
+ * Asserts that `value` is a {@link FetchOneXResult}.
+ */
+function assertIsFetchOneXResult(value) {
+    if (!isFetchOneXResult(value)) {
+        throw new Error('Expected a fetchOne result with a non-null, non undefined result');
+    }
+}
+/**
+ * Asserts that `value` is a {@link FetchSomeResult}.
+ */
+function assertIsFetchSomeResult(value) {
+    if (!isFetchSomeResult(value)) {
+        throw new Error('Expected a fetchSome result');
+    }
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,10 @@
+export { KyselyRizzolver } from './kysely-rizzolver.js';
+export type { AllTableFields, AnyTableField, KyselyRizzolverBuilderForSchema, KyselyRizzolverBuilderNoSchema, KyDB as RizzolverDB, TableName } from './kysely-rizzolver.js';
+export { assertIsFetchOneResult, assertIsFetchOneXResult, assertIsFetchSomeResult, isFetchOneResult, isFetchOneXResult, isFetchSomeResult, newFetchOneResult, newFetchOneXResult, newFetchSomeResult } from './fetch-result.js';
+export type { AsFetchOneResult, AsFetchOneXResult, AsFetchSomeResult, FetchOneResult, FetchOneXResult, FetchResult, FetchSomeResult } from './fetch-result.js';
+export { newSelector } from './selector.js';
+export type { Selector } from './selector.js';
+export { newQueryBuilder } from './query-builder.js';
+export type { QueryBuilder } from './query-builder.js';
+export { newModelCollection } from './model-collection.js';
+export type { ModelCollection } from './model-collection.js';

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newModelCollection = exports.newQueryBuilder = exports.newSelector = exports.newFetchSomeResult = exports.newFetchOneXResult = exports.newFetchOneResult = exports.isFetchSomeResult = exports.isFetchOneXResult = exports.isFetchOneResult = exports.assertIsFetchSomeResult = exports.assertIsFetchOneXResult = exports.assertIsFetchOneResult = exports.KyselyRizzolver = void 0;
+var kysely_rizzolver_js_1 = require("./kysely-rizzolver.js");
+Object.defineProperty(exports, "KyselyRizzolver", { enumerable: true, get: function () { return kysely_rizzolver_js_1.KyselyRizzolver; } });
+var fetch_result_js_1 = require("./fetch-result.js");
+Object.defineProperty(exports, "assertIsFetchOneResult", { enumerable: true, get: function () { return fetch_result_js_1.assertIsFetchOneResult; } });
+Object.defineProperty(exports, "assertIsFetchOneXResult", { enumerable: true, get: function () { return fetch_result_js_1.assertIsFetchOneXResult; } });
+Object.defineProperty(exports, "assertIsFetchSomeResult", { enumerable: true, get: function () { return fetch_result_js_1.assertIsFetchSomeResult; } });
+Object.defineProperty(exports, "isFetchOneResult", { enumerable: true, get: function () { return fetch_result_js_1.isFetchOneResult; } });
+Object.defineProperty(exports, "isFetchOneXResult", { enumerable: true, get: function () { return fetch_result_js_1.isFetchOneXResult; } });
+Object.defineProperty(exports, "isFetchSomeResult", { enumerable: true, get: function () { return fetch_result_js_1.isFetchSomeResult; } });
+Object.defineProperty(exports, "newFetchOneResult", { enumerable: true, get: function () { return fetch_result_js_1.newFetchOneResult; } });
+Object.defineProperty(exports, "newFetchOneXResult", { enumerable: true, get: function () { return fetch_result_js_1.newFetchOneXResult; } });
+Object.defineProperty(exports, "newFetchSomeResult", { enumerable: true, get: function () { return fetch_result_js_1.newFetchSomeResult; } });
+var selector_js_1 = require("./selector.js");
+Object.defineProperty(exports, "newSelector", { enumerable: true, get: function () { return selector_js_1.newSelector; } });
+var query_builder_js_1 = require("./query-builder.js");
+Object.defineProperty(exports, "newQueryBuilder", { enumerable: true, get: function () { return query_builder_js_1.newQueryBuilder; } });
+var model_collection_js_1 = require("./model-collection.js");
+Object.defineProperty(exports, "newModelCollection", { enumerable: true, get: function () { return model_collection_js_1.newModelCollection; } });