@casekit/orm 0.0.1-alpha.9 → 0.0.1-release-candidate.2

package/build/orm.findMany.js

@@ -0,0 +1,64 @@
+import { dropRight, groupBy } from "es-toolkit";
+import { get, set } from "es-toolkit/compat";
+import hash from "object-hash";
+import { buildFind } from "./builders/buildFind.js";
+import { findToSql } from "./sql/findToSql.js";
+import { getIncludedToManySubqueries } from "./util/getIncludedToManySubqueries.js";
+import { getLateralJoinValues } from "./util/getLateralJoinValues.js";
+import { rowToObject } from "./util/rowToObject.js";
+export const findMany = async (config, conn, middleware, modelName, query, lateralBy = []) => {
+    const builder = buildFind(config, middleware, modelName, query, lateralBy);
+    const statement = findToSql(builder);
+    config.logger.info("Executing findMany", {
+        sql: statement.pretty,
+        values: statement.values,
+    });
+    const results = await conn
+        .query(statement)
+        .then((res) => res.rows.map((row) => rowToObject(row, builder.columns)));
+    const relationQueries = [];
+    const includedToManySubqueries = getIncludedToManySubqueries(config, modelName, query);
+    // There's no getting around it, this bit is fiddly.
+    // Will do my best to explain what's going on.
+    for (const { modelName, query, path, from, to, extract, } of includedToManySubqueries) {
+        // this gets all the values of the 'from' columns on whichever the parent model
+        // is - either the top level model or one of the N:1 joined models.
+        const lateralBy = getLateralJoinValues(results, dropRight(path, 1), from, to);
+        // rather than awaiting the findMany query here, we'll push a promise
+        // into an array that we can await in parallel later.
+        const promise = findMany(config, conn, middleware, modelName, query, lateralBy).then((relationResults) => {
+            // we group the results by the hash of the 'to' columns so
+            // we can find the right list of values for each result
+            const lookup = groupBy(relationResults, (result) => hash(to.map((f) => result[f])));
+            for (const result of results) {
+                // if the relation is on the top level model of the query,
+                // the path length will be 1 and the parent of the relation
+                // will be the result itself. otherwise the relation
+                // will be on one of the N:1 relations of the top level model,
+                // so we need to look up this object in the result by path
+                const parent = path.length === 1
+                    ? result
+                    : get(result, dropRight(path, 1));
+                // if the relation is on an _optional_ N:1 relation of
+                // the query's top level model, then the value being joined from
+                // may not exist on the result. in that case there won't be any
+                // children to join so we ignore it.
+                if (parent !== undefined) {
+                    // finally we can look up the relation values for the result
+                    // and insert them into the result object at the correct path.
+                    const key = hash(from.map((c) => get(parent, c)));
+                    // if the relation is an N:N relation, the query we will have
+                    // done will be wrapped in an 1:N relation query on the join
+                    // model - so the result will be results of a _join model_
+                    // query, not the actual relation model. the extract function
+                    // makes sure that if this is the case, we extract the relevant
+                    // field from the results so everything is wired up correctly
+                    set(result, path, extract(lookup[key] ?? []));
+                }
+            }
+        });
+        relationQueries.push(promise);
+    }
+    await Promise.all(relationQueries);
+    return results;
+};

package/build/orm.findOne.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm-schema";
+import { Connection } from "./connection.js";
+import { FindParams } from "./types/FindParams.js";
+import { Middleware } from "./types/Middleware.js";
+export declare const findOne: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: FindParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>>;

package/build/orm.findOne.js

@@ -0,0 +1,12 @@
+import { findMany } from "./orm.findMany.js";
+export const findOne = async (config, conn, middleware, modelName, query) => {
+    config.logger.info("Delegating findOne to findMany");
+    const results = await findMany(config, conn, middleware, modelName, query);
+    if (results.length === 0) {
+        throw new Error("Expected one row, but found none");
+    }
+    if (results.length > 1) {
+        throw new Error("Expected one row, but found more");
+    }
+    return results[0];
+};

package/build/orm.js

@@ -0,0 +1,243 @@
+/**
+ * NB. You'll see a lot of `as unknown as` and other nasty looking typecasting
+ * in this file. This is because this is the boundary between the very specific
+ * types of the ORM as used by the user and the more general types of the ORMs
+ * implementation. The specific types are not helpful for the internals (in
+ * fact they would make it much harder if not impossible to write) - so we
+ * have this one specific place where we forcibly cast between the specific to
+ * the general - and nowhere else in the project should be doing this.
+ */
+import { mapValues, pick, pickBy } from "es-toolkit";
+import { ZodType, z } from "zod";
+import { getModel, normalizeConfig, } from "@casekit/orm-config";
+import { SQLStatement, sql } from "@casekit/sql";
+import { Connection } from "./connection.js";
+import { count } from "./orm.count.js";
+import { createMany } from "./orm.createMany.js";
+import { createOne } from "./orm.createOne.js";
+import { deleteMany } from "./orm.deleteMany.js";
+import { deleteOne } from "./orm.deleteOne.js";
+import { findMany } from "./orm.findMany.js";
+import { findOne } from "./orm.findOne.js";
+import { updateMany } from "./orm.updateMany.js";
+import { updateOne } from "./orm.updateOne.js";
+import { findManyResultSchema, findOneResultSchema, returningManyResultSchema, returningOneResultSchema, } from "./util/resultSchema.js";
+export const orm = (config) => {
+    return new Orm(normalizeConfig(config));
+};
+export class Orm {
+    config;
+    _connection;
+    _middleware;
+    constructor(config, connection, middleware) {
+        this.config = config;
+        this._connection = connection ?? new Connection(config);
+        this._middleware = middleware ?? [];
+    }
+    async connect() {
+        await this._connection.connect();
+    }
+    async close() {
+        await this._connection.close();
+    }
+    async transact(fn, options = { rollback: false }) {
+        const tx = await this._connection.startTransaction();
+        try {
+            const result = await fn(new Orm(this.config, tx, this._middleware));
+            if (options.rollback) {
+                await tx.rollback();
+            }
+            else {
+                await tx.commit();
+            }
+            return result;
+        }
+        catch (e) {
+            if (tx.open) {
+                await tx.rollback();
+            }
+            throw e;
+        }
+    }
+    getNextMiddleware(type) {
+        const mwIndex = this._middleware.findIndex((mw) => !!mw[type]);
+        if (mwIndex > -1) {
+            const next = this._middleware.map((mw, index) => index === mwIndex ? { ...mw, [type]: undefined } : mw);
+            const mw = this._middleware[mwIndex][type];
+            return [mw, next];
+        }
+        else {
+            return [null, this._middleware];
+        }
+    }
+    async findOne(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("findOne");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await findOne(this.config, this._connection, this._middleware, modelName, query);
+        const schema = findOneResultSchema(this.config, modelName, query);
+        return schema.parse(result);
+    }
+    async findMany(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("findMany");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await findMany(this.config, this._connection, this._middleware, modelName, query);
+        const schema = findManyResultSchema(this.config, modelName, query);
+        return schema.parse(result);
+    }
+    async count(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("count");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        return await count(this.config, this._connection, this._middleware, modelName, query);
+    }
+    async createOne(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("createOne");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await createOne(this.config, this._connection, this._middleware, modelName, query);
+        const schema = returningOneResultSchema(getModel(this.config.models, modelName), query.returning);
+        return schema.parse(result);
+    }
+    async createMany(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("createMany");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await createMany(this.config, this._connection, this._middleware, modelName, query);
+        const schema = returningManyResultSchema(getModel(this.config.models, modelName), query.returning);
+        return schema.parse(result);
+    }
+    async updateOne(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("updateOne");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await updateOne(this.config, this._connection, this._middleware, modelName, query);
+        const schema = returningOneResultSchema(getModel(this.config.models, modelName), query.returning);
+        return schema.parse(result);
+    }
+    async updateMany(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("updateMany");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await updateMany(this.config, this._connection, this._middleware, modelName, query);
+        const schema = returningManyResultSchema(getModel(this.config.models, modelName), query.returning);
+        return schema.parse(result);
+    }
+    async deleteOne(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("deleteOne");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await deleteOne(this.config, this._connection, this._middleware, modelName, query);
+        const schema = returningOneResultSchema(getModel(this.config.models, modelName), query.returning);
+        return schema.parse(result);
+    }
+    async deleteMany(modelName, query) {
+        const [mw, next] = this.getNextMiddleware("deleteMany");
+        if (mw) {
+            const db = new Orm(this.config, this._connection, next);
+            // the type cast here is needed for the recursive call because
+            // otherwise typescript goes absolutely haywire causing an OOM error
+            return (await mw(db, modelName, query));
+        }
+        const result = await deleteMany(this.config, this._connection, this._middleware, modelName, query);
+        const schema = returningManyResultSchema(getModel(this.config.models, modelName), query.returning);
+        return schema.parse(result);
+    }
+    /**
+     * In some parts of your app - e.g. in the non-tenant specific parts of
+     * a multi-tenant app, where you don't want to restrict by tenant_id -
+     * you may want to only make a subset of models available for querying.
+     * This method allows you to do that by creating a restricted copy of
+     * the ORM with access only to the models you specify.
+     */
+    restrict(allowed) {
+        if (this._connection.isTransaction()) {
+            throw new Error("Cannot create restricted ORM in a transaction");
+        }
+        // TODO - update this to also include join models for N:N relations
+        const config = {
+            ...this.config,
+            models: mapValues(pick(this.config.models, allowed), (model) => ({
+                ...model,
+                relations: pickBy(model.relations, (r) => 
+                // @ts-expect-error - need TS to treat allowed as a string[] here
+                // but it wants to treat it as the more specific "Allowed" type
+                allowed.includes(r.model)),
+            })),
+        };
+        return new Orm(config, this._connection, this._middleware);
+    }
+    /** Returns a new ORM instance with middleware applied.
+     * The new ORM instance shares the same connection as
+     * the one it is called on, but the original instance
+     * does not have the middleware applied. This means
+     * this method can be called multiple times to apply
+     * different middleware to different ORM instances.
+     */
+    middleware(middleware) {
+        return new Orm(this.config, this._connection, middleware);
+    }
+    query(schemaOrStatementOrFragments, ...values) {
+        if (schemaOrStatementOrFragments instanceof ZodType) {
+            return this.queryWithSchema(schemaOrStatementOrFragments);
+        }
+        if (schemaOrStatementOrFragments instanceof SQLStatement) {
+            return this.queryWithSQLStatement(schemaOrStatementOrFragments);
+        }
+        return this.queryWithTemplateLiteral(schemaOrStatementOrFragments, ...values);
+    }
+    queryWithTemplateLiteral(fragments, ...values) {
+        return this._connection
+            .query(sql(fragments, ...values))
+            .then((result) => result.rows);
+    }
+    queryWithSQLStatement(statement) {
+        const result = this._connection.query(statement);
+        if (statement.schema) {
+            const schema = statement.schema;
+            return result.then((result) => z.array(schema).parse(result.rows));
+        }
+        else {
+            return result.then((result) => result.rows);
+        }
+    }
+    queryWithSchema(schema) {
+        return (fragments, ...values) => {
+            const result = this._connection.query(sql(fragments, ...values));
+            return result.then((result) => z.array(schema).parse(result.rows));
+        };
+    }
+}

package/build/orm.restrict.d.ts

@@ -0,0 +1,7 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { Config, ModelName } from "@casekit/orm-schema";
+import { Connection } from "./connection.js";
+import { Orm } from "./orm.js";
+import { Middleware } from "./types/Middleware.js";
+import { RestrictModels } from "./types/RestrictModels.js";
+export declare const restrict: <const C extends Config, const Allowed extends [...ModelName<C["models"]>[]]>(config: NormalizedConfig, allowed: string[], connection: Connection, middleware: Middleware[]) => Orm<RestrictModels<C, Allowed[number]>>;

package/build/orm.restrict.js

@@ -0,0 +1,52 @@
+import { Orm } from "./orm.js";
+export const restrict = (config, allowed, connection, middleware) => {
+    if (connection.isTransaction()) {
+        throw new Error("Cannot create restricted ORM in a transaction");
+    }
+    const lookup = new Set(allowed);
+    const models = Object.keys(config.models).reduce((acc, name) => {
+        if (lookup.has(name)) {
+            return {
+                ...acc,
+                [name]: {
+                    ...config.models[name],
+                    relations: Object.keys(config.models[name].relations).reduce((acc, name) => {
+                        const relation = config.models[name].relations[name];
+                        if (!lookup.has(relation.model)) {
+                            return {
+                                ...acc,
+                                get [name]() {
+                                    throw new Error(`Relation "${name}" references model "${relation.model}" which is not permitted in this restricted ORM instance`);
+                                },
+                            };
+                        }
+                        else if (relation.type === "N:N" &&
+                            !lookup.has(relation.through.model)) {
+                            return {
+                                ...acc,
+                                get [name]() {
+                                    throw new Error(`Relation "${name}" references model "${relation.through.model}" which is not permitted in this restricted ORM instance`);
+                                },
+                            };
+                        }
+                        else {
+                            return {
+                                ...acc,
+                                [name]: relation,
+                            };
+                        }
+                    }, {}),
+                },
+            };
+        }
+        else {
+            return {
+                ...acc,
+                get [name]() {
+                    throw new Error(`Model ${name} is not permitted in this restricted ORM instance`);
+                },
+            };
+        }
+    }, {});
+    return new Orm({ ...config, models }, connection, middleware);
+};

package/build/orm.updateMany.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm-schema";
+import { Connection } from "./connection.js";
+import { Middleware } from "./types/Middleware.js";
+import { UpdateParams } from "./types/UpdateParams.js";
+export declare const updateMany: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown>[] | number>;

package/build/orm.updateMany.js

@@ -0,0 +1,29 @@
+import { buildUpdate } from "./builders/buildUpdate.js";
+import { updateToSql } from "./sql/updateToSql.js";
+import { rowToObject } from "./util/rowToObject.js";
+export const updateMany = async (config, conn, middleware, modelName, query) => {
+    if (Object.keys(query.set).length === 0) {
+        throw new Error("Update requires at least one value to set");
+    }
+    const builder = buildUpdate(config, middleware, modelName, query);
+    const statement = updateToSql(builder);
+    config.logger.info("Executing updateMany", {
+        sql: statement.pretty,
+        values: statement.values,
+    });
+    const tx = await conn.startTransaction();
+    try {
+        const result = await tx.query(statement);
+        await tx.commit();
+        if (query.returning) {
+            return result.rows.map((row) => rowToObject(row, builder.returning));
+        }
+        else {
+            return result.rowCount ?? 0;
+        }
+    }
+    catch (e) {
+        await tx.rollback();
+        throw e;
+    }
+};

package/build/orm.updateOne.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedConfig } from "@casekit/orm-config";
+import { ModelDefinitions, OperatorDefinitions } from "@casekit/orm-schema";
+import { Connection } from "./connection.js";
+import { Middleware } from "./types/Middleware.js";
+import { UpdateParams } from "./types/UpdateParams.js";
+export declare const updateOne: (config: NormalizedConfig, conn: Connection, middleware: Middleware[], modelName: string, query: UpdateParams<ModelDefinitions, OperatorDefinitions, string>) => Promise<Record<string, unknown> | number | null>;

package/build/orm.updateOne.js

@@ -0,0 +1,35 @@
+import { buildUpdate } from "./builders/buildUpdate.js";
+import { updateToSql } from "./sql/updateToSql.js";
+import { rowToObject } from "./util/rowToObject.js";
+export const updateOne = async (config, conn, middleware, modelName, query) => {
+    if (Object.keys(query.set).length === 0) {
+        throw new Error("Update requires at least one value to set");
+    }
+    const builder = buildUpdate(config, middleware, modelName, query);
+    const statement = updateToSql(builder);
+    config.logger.info("Executing updateOne", {
+        sql: statement.pretty,
+        values: statement.values,
+    });
+    const tx = await conn.startTransaction();
+    try {
+        const result = await tx.query(statement);
+        if (!result.rowCount || result.rowCount === 0) {
+            throw new Error("Update one failed to update a row");
+        }
+        else if (result.rowCount > 1) {
+            throw new Error("Update one would have updated more than one row");
+        }
+        await tx.commit();
+        if (query.returning) {
+            return rowToObject(result.rows[0], builder.returning);
+        }
+        else {
+            return result.rowCount;
+        }
+    }
+    catch (e) {
+        await tx.rollback();
+        throw e;
+    }
+};

package/build/sql/countToSql.d.ts

@@ -0,0 +1,3 @@
+import { SQLStatement } from "@casekit/sql";
+import { CountBuilder } from "#builders/types.js";
+export declare const countToSql: (builder: CountBuilder) => SQLStatement;

package/build/sql/countToSql.js

@@ -0,0 +1,11 @@
+import { sql } from "@casekit/sql";
+import { joinClause, tableName } from "./util.js";
+export const countToSql = (builder) => {
+    const { table, joins, where } = builder;
+    return sql `
+            SELECT count(1) AS "count"
+            FROM ${tableName(table)}
+            ${sql.join(joins.map(joinClause), "\n")}
+            ${where ? sql `WHERE ${where}\n` : sql ``}
+        `;
+};

package/build/sql/countToSql.test.d.ts

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