@casekit/orm 0.0.1-alpha.12 → 0.0.1-alpha.13

package/src/orm.ts

@@ -1,370 +0,0 @@
-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[]
-    ): Promise<T[]> {
-        const query = sql(fragments, ...variables);
-        if (process.env.ORM_VERBOSE_LOGGING) {
-            console.log(query.text);
-            console.log(query.values);
-        }
-        const result = await this.connection.query<T>(query);
-        return result.rows;
-    }
-
-    public async queryOne<T extends QueryResultRow>(
-        fragments: TemplateStringsArray,
-        ...variables: readonly unknown[]
-    ): Promise<T> {
-        const query = sql(fragments, ...variables);
-        if (process.env.ORM_VERBOSE_LOGGING) {
-            console.log(query.text);
-            console.log(query.values);
-        }
-        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

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

package/src/pull/introspect/getForeignKeys.ts

@@ -1,64 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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,
-    };
-};

package/src/pull/pull.ts

@@ -1,78 +0,0 @@
-import fs from "fs";
-import { camelCase } from "lodash-es";
-import path from "path";
-import pg from "pg";
-
-import { getForeignKeys } from "./introspect/getForeignKeys";
-import { getPrimaryKeys } from "./introspect/getPrimaryKeys";
-import { getTables } from "./introspect/getTables";
-import { getUniqueConstraints } from "./introspect/getUniqueConstraints";
-import { renderModel } from "./render/renderModel";
-import { renderModelsIndex } from "./render/renderModelsIndex";
-import { renderRelations } from "./render/renderRelations";
-import { renderRelationsIndex } from "./render/renderRelationsIndex";
-import { format } from "./util/format";
-
-export const pull = async (
-    client: pg.Client,
-    opts: { schema: string; outDir: string },
-) => {
-    const tables = await getTables(client, opts.schema);
-    const primaryKeys = await getPrimaryKeys(client, opts.schema);
-    const uniqueConstraints = await getUniqueConstraints(client, opts.schema);
-    const foreignKeys = await getForeignKeys(client, opts.schema);
-
-    fs.mkdirSync(path.resolve(opts.outDir, "models"), { recursive: true });
-
-    for (const [table, columns] of Object.entries(tables)) {
-        fs.writeFileSync(
-            path.resolve(opts.outDir, "models", `${camelCase(table)}.model.ts`),
-            await renderModel({
-                table,
-                columns,
-                primaryKey: primaryKeys[table] ?? [],
-                uniqueConstraints: uniqueConstraints[table] ?? [],
-                foreignKeys: foreignKeys[table] ?? [],
-            }),
-            { encoding: "utf-8" },
-        );
-    }
-
-    fs.writeFileSync(
-        path.resolve(opts.outDir, "models.ts"),
-        await renderModelsIndex(Object.keys(tables)),
-        { encoding: "utf-8" },
-    );
-
-    for (const table of Object.keys(tables)) {
-        fs.writeFileSync(
-            path.resolve(
-                opts.outDir,
-                "models",
-                `${camelCase(table)}.relations.ts`,
-            ),
-            await renderRelations({
-                table,
-                foreignKeys: foreignKeys,
-            }),
-            { encoding: "utf-8" },
-        );
-    }
-
-    fs.writeFileSync(
-        path.resolve(opts.outDir, "relations.ts"),
-        await renderRelationsIndex(Object.keys(tables)),
-        { encoding: "utf-8" },
-    );
-
-    if (!fs.existsSync(path.resolve(opts.outDir, "index.ts"))) {
-        fs.writeFileSync(
-            path.resolve(opts.outDir, "index.ts"),
-            await format(`
-            export { models, type Models } from "./models";
-            export { relations, type Relations } from "./relations";
-        `),
-            { encoding: "utf-8" },
-        );
-    }
-};