@casekit/orm 0.0.1-alpha.0

package/src/migrate/sql/dropSchemasSql.ts

@@ -0,0 +1,15 @@
+import { uniq } from "lodash-es";
+import pgfmt from "pg-format";
+
+import { BaseOrm } from "../../schema/types/base/BaseOrm";
+import { SQLStatement } from "../../sql";
+
+export const dropSchemasSql = (db: BaseOrm): SQLStatement => {
+    const schemas = uniq(Object.values(db.models).map((m) => m.schema));
+
+    return new SQLStatement(
+        schemas
+            .map((s) => pgfmt("DROP SCHEMA IF EXISTS %I CASCADE;", s))
+            .join("\n"),
+    );
+};

package/src/migrate/sql/dropTableSql.ts

@@ -0,0 +1,13 @@
+import pgfmt from "pg-format";
+
+import { BaseModel } from "../../schema/types/base/BaseModel";
+import { SQLStatement } from "../../sql";
+
+export const dropTableSql = (model: BaseModel): SQLStatement => {
+    const statement = pgfmt(
+        "DROP TABLE IF EXISTS %I.%I CASCADE;",
+        model.schema ?? "public",
+        model.table,
+    );
+    return new SQLStatement(statement);
+};

package/src/orm.query.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "vitest";
+
+import { db } from "./test/db";
+import { seed } from "./test/seed";
+
+describe("orm.query", () => {
+    test("allows arbitrary sql queries to be run against the database", async () => {
+        await db.transact(
+            async (db) => {
+                await seed(db, {
+                    users: [
+                        {
+                            username: "Russell",
+                            tenants: [{ name: "Popova Park", posts: 6 }],
+                        },
+                    ],
+                });
+
+                const result = await db.query<{ total: number }>`
+                    select count(1)::int as total from casekit.post;
+                `;
+
+                expect(result[0]).toEqual({ total: 6 });
+            },
+            { rollback: true },
+        );
+    });
+});

package/src/orm.ts

@@ -0,0 +1,362 @@
+import { QueryResultRow } from "pg";
+import { z } from "zod";
+
+import { Connection } from "./Connection";
+import { OrmError } from "./errors";
+import { count } from "./queries/count";
+import { BaseCountParams } from "./queries/count/types/BaseCountParams";
+import { CountParams } from "./queries/count/types/CountParams";
+import { createResultSchema } from "./queries/create/createResultSchema";
+import { BaseCreateManyParams } from "./queries/create/types/BaseCreateManyParams";
+import { BaseCreateOneParams } from "./queries/create/types/BaseCreateOneParams";
+import { CreateManyParams } from "./queries/create/types/CreateManyParams";
+import { CreateManyResult } from "./queries/create/types/CreateManyResult";
+import { CreateOneParams } from "./queries/create/types/CreateOneParams";
+import { CreateOneResult } from "./queries/create/types/CreateOneResult";
+import { createMany } from "./queries/createMany";
+import { createOne } from "./queries/createOne";
+import { deleteResultSchema } from "./queries/delete/deleteResultSchema";
+import { BaseDeleteParams } from "./queries/delete/types/BaseDeleteParams";
+import { DeleteManyResult } from "./queries/delete/types/DeleteManyResult";
+import { DeleteOneResult } from "./queries/delete/types/DeleteOneResult";
+import { DeleteParams } from "./queries/delete/types/DeleteParams";
+import { deleteMany } from "./queries/deleteMany";
+import { deleteOne } from "./queries/deleteOne";
+import { findResultSchema } from "./queries/find/findResultSchema";
+import { FindManyParams } from "./queries/find/types/FindManyParams";
+import { FindManyResult } from "./queries/find/types/FindManyResult";
+import { FindOneResult } from "./queries/find/types/FindOneResult";
+import { findMany } from "./queries/findMany";
+import { findOne } from "./queries/findOne";
+import { BaseUpdateParams } from "./queries/update/types/BaseUpdateParams";
+import { UpdateManyResult } from "./queries/update/types/UpdateManyResult";
+import { UpdateOneResult } from "./queries/update/types/UpdateOneResult";
+import { UpdateParams } from "./queries/update/types/UpdateParams";
+import { updateResultSchema } from "./queries/update/updateResultSchema";
+import { updateMany } from "./queries/updateMany";
+import { updateOne } from "./queries/updateOne";
+import { populateConfiguration } from "./schema/populate/populateConfiguration";
+import { BaseConfiguration } from "./schema/types/base/BaseConfiguration";
+import { BaseModel } from "./schema/types/base/BaseModel";
+import { ModelName } from "./schema/types/helpers/ModelName";
+import { LooseModelDefinitions } from "./schema/types/loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "./schema/types/loose/LooseRelationsDefinitions";
+import { validateConfiguration } from "./schema/validate/validateConfiguration";
+import { sql } from "./sql";
+import { Configuration } from "./types/Configuration";
+import { DisallowExtraKeys } from "./types/util/DisallowExtraKeys";
+
+export class Orm<
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+> {
+    public config: BaseConfiguration;
+
+    /**
+     * As a nicety, we expose the models directly on the Orm instance with literal keys
+     * for the models. The deeper values are not literally typed however.
+     */
+    public get models(): {
+        [M in ModelName<Models>]: BaseModel;
+    } {
+        return this.config.models as {
+            [M in ModelName<Models>]: BaseModel;
+        };
+    }
+
+    public get connection(): Connection {
+        return this.config.connection;
+    }
+
+    constructor(config: BaseConfiguration) {
+        this.config = config;
+    }
+
+    public async transact<T>(
+        cb: (db: Orm<Models, Relations>) => Promise<T>,
+        opts = { rollback: false },
+    ): Promise<T> {
+        return await this.connection.transact(async (conn) => {
+            return await cb(
+                new Orm<Models, Relations>({
+                    ...this.config,
+                    connection: conn,
+                }),
+            );
+        }, opts);
+    }
+
+    public async findMany<
+        M extends ModelName<Models>,
+        Q extends FindManyParams<Models, Relations, M>,
+    >(
+        m: M,
+        query: DisallowExtraKeys<FindManyParams<Models, Relations, M>, Q>,
+    ): Promise<FindManyResult<Models, Relations, M, Q>> {
+        const results = await findMany(this.connection, this.config, m, query);
+        const parser = z.array(findResultSchema(this.config, m, query));
+        return parser.parse(results) as FindManyResult<Models, Relations, M, Q>;
+    }
+
+    public async findOne<
+        M extends ModelName<Models>,
+        Q extends FindManyParams<Models, Relations, M>,
+    >(
+        m: M,
+        query: DisallowExtraKeys<FindManyParams<Models, Relations, M>, Q>,
+    ): Promise<FindOneResult<Models, Relations, M, Q>> {
+        const result = await findOne(this.connection, this.config, m, query);
+        const parser = findResultSchema(this.config, m, query);
+        return parser.parse(result) as FindOneResult<Models, Relations, M, Q>;
+    }
+
+    public async createOne<
+        M extends ModelName<Models>,
+        P extends CreateOneParams<Models, M>,
+    >(
+        m: M,
+        params: DisallowExtraKeys<CreateOneParams<Models, M>, P>,
+    ): Promise<CreateOneResult<Models, M, P>> {
+        const result = await createOne(
+            this.connection,
+            this.config,
+            m,
+            params as BaseCreateOneParams,
+        );
+        const parser = createResultSchema(
+            this.config,
+            m,
+            params as BaseCreateOneParams,
+        );
+        return parser.parse(result) as CreateOneResult<Models, M, P>;
+    }
+
+    public async createMany<
+        M extends ModelName<Models>,
+        P extends CreateManyParams<Models, M>,
+    >(
+        m: M,
+        params: DisallowExtraKeys<CreateManyParams<Models, M>, P>,
+    ): Promise<CreateManyResult<Models, M, P>> {
+        const result = await createMany(
+            this.connection,
+            this.config,
+            m,
+            params as BaseCreateManyParams,
+        );
+        if (typeof result === "number")
+            return result as CreateManyResult<Models, M, P>;
+
+        const parser = z.array(
+            createResultSchema(this.config, m, params as BaseCreateManyParams),
+        );
+        return parser.parse(result) as CreateManyResult<Models, M, P>;
+    }
+
+    public async updateOne<
+        M extends ModelName<Models>,
+        P extends UpdateParams<Models, M>,
+    >(
+        m: M,
+        params: DisallowExtraKeys<UpdateParams<Models, M>, P>,
+    ): Promise<UpdateOneResult<Models, M, P>> {
+        const result = await updateOne(
+            this.connection,
+            this.config,
+            m,
+            params as BaseUpdateParams,
+        );
+        const parser = updateResultSchema(
+            this.config,
+            m,
+            params as BaseUpdateParams,
+        );
+        return parser.parse(result) as UpdateOneResult<Models, M, P>;
+    }
+
+    public async updateMany<
+        M extends ModelName<Models>,
+        P extends UpdateParams<Models, M>,
+    >(
+        m: M,
+        params: DisallowExtraKeys<UpdateParams<Models, M>, P>,
+    ): Promise<UpdateManyResult<Models, M, P>> {
+        const result = await updateMany(
+            this.connection,
+            this.config,
+            m,
+            params as BaseUpdateParams,
+        );
+
+        if (typeof result === "number")
+            return result as UpdateManyResult<Models, M, P>;
+
+        const parser = z.array(
+            updateResultSchema(this.config, m, params as BaseUpdateParams),
+        );
+        return parser.parse(result) as UpdateManyResult<Models, M, P>;
+    }
+
+    public async deleteOne<
+        M extends ModelName<Models>,
+        P extends DeleteParams<Models, M>,
+    >(
+        m: M,
+        params: DisallowExtraKeys<DeleteParams<Models, M>, P>,
+    ): Promise<DeleteOneResult<Models, M, P>> {
+        const parser = deleteResultSchema(
+            this.config,
+            m,
+            params as BaseDeleteParams,
+        );
+
+        if (this.config.middleware.delete?.deleteOne) {
+            const result = await this.config.middleware.delete.deleteOne(
+                params,
+                {
+                    model: m,
+                    config: this.config,
+                    deleteOne: (params) => {
+                        return deleteOne(
+                            this.connection,
+                            this.config,
+                            m,
+                            params,
+                            // TODO figure out a better way to type this
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        ) as any;
+                    },
+                    updateOne: (params) => {
+                        return updateOne(
+                            this.connection,
+                            this.config,
+                            m,
+                            params,
+                            // TODO figure out a better way to type this
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        ) as any;
+                    },
+                },
+            );
+
+            return parser.parse(result) as DeleteOneResult<Models, M, P>;
+        } else {
+            const result = await deleteOne(
+                this.connection,
+                this.config,
+                m,
+                params as BaseDeleteParams,
+            );
+
+            return parser.parse(result) as DeleteOneResult<Models, M, P>;
+        }
+    }
+
+    public async deleteMany<
+        M extends ModelName<Models>,
+        P extends DeleteParams<Models, M>,
+    >(
+        m: M,
+        params: DisallowExtraKeys<DeleteParams<Models, M>, P>,
+    ): Promise<DeleteManyResult<Models, M, P>> {
+        const parser = z.array(
+            deleteResultSchema(this.config, m, params as BaseDeleteParams),
+        );
+
+        if (this.config.middleware.delete?.deleteMany) {
+            const result = await this.config.middleware.delete.deleteMany(
+                params,
+                {
+                    model: m,
+                    config: this.config,
+                    deleteMany: (params) => {
+                        return deleteMany(
+                            this.connection,
+                            this.config,
+                            m,
+                            params,
+                            // TODO figure out a better way to type this
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        ) as any;
+                    },
+                    updateMany: (params) => {
+                        return updateMany(
+                            this.connection,
+                            this.config,
+                            m,
+                            params,
+                            // TODO figure out a better way to type this
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        ) as any;
+                    },
+                },
+            );
+
+            return (
+                typeof result === "number" ? result : parser.parse(result)
+            ) as DeleteManyResult<Models, M, P>;
+        } else {
+            const result = await deleteMany(
+                this.connection,
+                this.config,
+                m,
+                params as BaseDeleteParams,
+            );
+
+            return (
+                typeof result === "number" ? result : parser.parse(result)
+            ) as DeleteManyResult<Models, M, P>;
+        }
+    }
+
+    public async count<
+        M extends ModelName<Models>,
+        P extends CountParams<Models, Relations, M>,
+    >(
+        m: M,
+        params: DisallowExtraKeys<CountParams<Models, Relations, M>, P>,
+    ): Promise<number> {
+        const result = await count(
+            this.connection,
+            this.config,
+            m,
+            params as BaseCountParams,
+        );
+        return z.coerce.number().parse(result);
+    }
+
+    public async query<T extends QueryResultRow>(
+        fragments: TemplateStringsArray,
+        ...variables: readonly unknown[]
+    ) {
+        const query = sql(fragments, ...variables);
+        const result = await this.connection.query<T>(query);
+        return result.rows;
+    }
+
+    public async queryOne<T extends QueryResultRow>(
+        fragments: TemplateStringsArray,
+        ...variables: readonly unknown[]
+    ) {
+        const query = sql(fragments, ...variables);
+        const result = await this.connection.query<T>(query);
+        if (result.rowCount === 0 || result.rowCount === null)
+            throw new OrmError("No rows returned from query");
+
+        if (result.rowCount > 1)
+            throw new OrmError("More than one row returned from query");
+
+        return result.rows[0];
+    }
+}
+
+export const orm = <
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+>(
+    config: Configuration<Models, Relations>,
+): Orm<Models, Relations> => {
+    const populatedSchema = populateConfiguration(config);
+    validateConfiguration(populatedSchema);
+    return new Orm<Models, Relations>(populatedSchema);
+};

package/src/pull/index.ts

@@ -0,0 +1 @@
+export { pull } from "./pull";

package/src/pull/introspect/getForeignKeys.ts

@@ -0,0 +1,64 @@
+import { groupBy } from "lodash-es";
+import pg from "pg";
+
+import { ForeignKey } from "../types/ForeignKey";
+
+export const getForeignKeys = async (
+    client: pg.Client,
+    schema: string,
+): Promise<Record<string, ForeignKey[]>> => {
+    const result = await client.query<ForeignKey>(
+        `
+        SELECT
+        	conname "constraintName",
+        	table_from as "tableFrom",
+        	array_agg(columns_from::text) AS "columnsFrom",
+        	table_to AS "tableTo",
+        	array_agg(columns_to::text) AS "columnsTo"
+        FROM (
+        	SELECT
+        		conname,
+        		conrelid::regclass AS table_from,
+        		a.attname AS columns_from,
+        		confrelid::regclass AS table_to,
+        		af.attname AS columns_to
+        	FROM
+        		pg_attribute AS af,
+        		pg_attribute AS a,
+        		pg_class c,
+        		pg_namespace n,
+        		(
+        			SELECT
+        				conname,
+        				conrelid,
+        				confrelid,
+        				conkey[i] AS conkey,
+        				confkey[i] AS confkey
+        			FROM (
+        				SELECT
+        					conname,
+        					conrelid,
+        					confrelid,
+        					conkey,
+        					confkey,
+        					generate_series(1, array_upper(conkey, 1)) AS i
+        				FROM
+        					pg_constraint
+        				WHERE
+        					contype = 'f') AS ss) AS ss2
+        		WHERE
+        			af.attnum = confkey
+        			AND af.attrelid = confrelid
+        			AND a.attnum = conkey
+        			AND a.attrelid = conrelid
+        			AND af.attrelid = c.oid
+        			AND c.relnamespace = n.oid
+        			AND n.nspname = $1) AS ss3
+        GROUP BY
+        	conname,
+        	table_to,
+        	table_from;`,
+        [schema],
+    );
+    return groupBy(result.rows, "tableFrom");
+};

package/src/pull/introspect/getPrimaryKeys.ts

@@ -0,0 +1,26 @@
+import { groupBy, mapValues, sortBy } from "lodash-es";
+import pg from "pg";
+
+import { sql } from "../../sql";
+import { PrimaryKey } from "../types/PrimaryKey";
+
+export const getPrimaryKeys = async (
+    client: pg.Client,
+    schema: string,
+): Promise<Record<string, string[]>> => {
+    const results = await client.query<PrimaryKey>(
+        sql`select
+             cc.table_name as table,
+             cc.constraint_name as name,
+             cc.column_name as column,
+             cc.ordinal_position as ordinal
+             from information_schema.table_constraints c
+             join information_schema.key_column_usage cc on c.constraint_name = cc.constraint_name and c.constraint_schema = cc.constraint_schema and c.table_name = cc.table_name
+             where c.constraint_type = 'PRIMARY KEY'
+             and c.constraint_schema = ${schema}`,
+    );
+
+    return mapValues(groupBy(results.rows, "table"), (columns) =>
+        sortBy(columns, "ordinal").map((c) => c.column),
+    );
+};

package/src/pull/introspect/getTables.ts

@@ -0,0 +1,51 @@
+import { groupBy, mapValues, sortBy } from "lodash-es";
+import pg from "pg";
+
+import { sql } from "../../sql";
+import { ColumnMeta } from "../types/ColumnMeta";
+
+export const getTables = async (client: pg.Client, schema: string) => {
+    const results = await client.query<ColumnMeta>(
+        sql`WITH array_columns AS (
+            	SELECT
+            		ns.nspname AS schema,
+            		(c.oid::regclass)::text AS table,
+            		attname AS column,
+            		attndims AS cardinality
+            	FROM
+            		pg_class c
+            		JOIN pg_attribute a ON c.oid = attrelid
+            		JOIN pg_type t ON t.oid = atttypid
+            		JOIN pg_catalog.pg_namespace AS ns ON c.relnamespace = ns.oid
+            	WHERE
+            		a.attnum > 0
+            )
+            SELECT
+            	c.table_name AS table,
+            	c.column_name AS name,
+            	c.ordinal_position AS ordinal,
+            	c.column_default AS default,
+            	CASE WHEN c.is_nullable = 'YES' THEN
+            		TRUE
+            	ELSE
+            		FALSE
+            	END AS nullable,
+            	c.data_type AS type,
+            	e.data_type AS elementtype,
+            	coalesce(arr.cardinality, 0) AS cardinality
+            FROM
+            	information_schema.columns c
+            	LEFT JOIN information_schema.element_types e ON c.table_catalog = e.object_catalog
+            		AND c.table_schema = e.object_schema
+            		AND e.collection_type_identifier = c.dtd_identifier
+            		AND c.data_type = 'ARRAY'
+            	LEFT JOIN array_columns arr ON arr.schema = c.table_schema
+            		AND arr.table = c.table_name
+            		AND arr.column = c.column_name
+            WHERE
+            	c.table_schema = ${schema}`,
+    );
+    return mapValues(groupBy(results.rows, "table"), (columns) =>
+        sortBy(columns, "ordinal"),
+    );
+};

package/src/pull/introspect/getUniqueConstraints.ts

@@ -0,0 +1,39 @@
+import { groupBy } from "lodash-es";
+import pg from "pg";
+
+import { sql } from "../../sql";
+import { parseCreateUniqueIndexStatement } from "../parse/parseCreateUniqueIndexStatement";
+import { UniqueConstraint } from "../types/UniqueConstraint";
+
+/**
+ * Doing this with string manipulation in this way feels pretty hacky,
+ * so it would be great if we can find a better way to do it.
+ * In particular, this is likely to break if column names have parentheses in them.
+ * Couldn't find a way to easily get the columns and conditions from the
+ * information_schema * or pg_catalog tables though.
+ */
+export const getUniqueConstraints = async (
+    client: pg.Client,
+    schema: string,
+): Promise<Record<string, UniqueConstraint[]>> => {
+    const results = await client.query<{
+        table: string;
+        definition: string;
+        name: string;
+    }>(
+        sql`select i.tablename as table, i.indexdef as definition, i.indexname as name
+            from pg_indexes i
+            left join pg_constraint c on i.indexname = c.conname and c.contype in ('p', 'x')
+            where schemaname = ${schema}
+            and c.conname is null
+            and indexdef like 'CREATE UNIQUE INDEX%';
+        `,
+    );
+
+    const parsed = results.rows.map((result) => ({
+        ...result,
+        ...parseCreateUniqueIndexStatement(result.definition),
+    }));
+
+    return groupBy(parsed, "table");
+};

package/src/pull/parse/parseCreateUniqueIndexStatement.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "vitest";
+
+import { parseCreateUniqueIndexStatement } from "./parseCreateUniqueIndexStatement";
+
+describe("parseCreateUniqueIndexStatement", () => {
+    test("it extracts out the index's columns and a condition if present", () => {
+        const parsed = parseCreateUniqueIndexStatement(
+            "CREATE UNIQUE INDEX field_value_field_id_ordinal ON casekit.field_value USING btree (field_id, ordinal) WHERE (deleted_at IS NULL)",
+        );
+
+        expect(parsed.columns).toEqual(["field_id", "ordinal"]);
+        expect(parsed.where).toEqual("deleted_at IS NULL");
+    });
+});

package/src/pull/parse/parseCreateUniqueIndexStatement.ts

@@ -0,0 +1,19 @@
+export const parseCreateUniqueIndexStatement = (
+    command: string,
+): { columns: string[]; where?: string; nullsNotDistinct: boolean } => {
+    const columnsMatch = command.match(/ON[^(]*\(([^)]*)\)/);
+    if (!columnsMatch || !columnsMatch[1])
+        throw new Error("Unable to parse unique index statement: " + command);
+
+    const columns = columnsMatch[1].split(", ");
+
+    const whereMatch = command.match(/WHERE[^(]*\(([^)]*)\)/);
+
+    const nullsNotDistinct = !!command.match(/NULLS NOT DISTINCT/);
+
+    return {
+        columns,
+        where: whereMatch ? whereMatch[1] : undefined,
+        nullsNotDistinct,
+    };
+};