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

package/src/pull/render/renderModel.test.ts

@@ -1,144 +0,0 @@
-import { unindent } from "@casekit/unindent";
-
-import { describe, expect, test } from "vitest";
-
-import { renderModel } from "./renderModel";
-
-describe("renderModel", () => {
-    test("it renders a valid model definition given introspection results", async () => {
-        expect(
-            await renderModel({
-                table: "my_table",
-                columns: [
-                    {
-                        name: "id",
-                        type: "uuid",
-                        default: "uuid_generate_v4()",
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 0,
-                        nullable: false,
-                    },
-                    {
-                        name: "name",
-                        type: "text",
-                        default: null,
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 1,
-                        nullable: true,
-                    },
-                ],
-                uniqueConstraints: [
-                    {
-                        name: "my_table_name_unique",
-                        table: "my_table",
-                        definition:
-                            "CREATE UNIQUE INDEX ON my_table USING btree (name)",
-                        columns: ["name"],
-                        where: undefined,
-                    },
-                ],
-                foreignKeys: [],
-                primaryKey: ["id"],
-            }),
-        ).toEqual(
-            unindent`
-            import { type ModelDefinition, type ModelType, sql } from "@casekit/orm";
-
-            export const myTable = {
-                table: "my_table",
-                columns: {
-                    id: {
-                        name: "id",
-                        type: "uuid",
-                        primaryKey: true,
-                        default: sql\`uuid_generate_v4()\`,
-                    },
-                    name: { name: "name", type: "text", unique: true, nullable: true },
-                },
-            } as const satisfies ModelDefinition;
-
-            export type MyTable = ModelType<typeof myTable>;
-        ` + "\n",
-        );
-    });
-    test("it renders a valid model definition given introspection results with a column-local unique constraint", async () => {
-        expect(
-            await renderModel({
-                table: "my_table",
-                columns: [
-                    {
-                        name: "id",
-                        type: "uuid",
-                        default: "uuid_generate_v4()",
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 0,
-                        nullable: false,
-                    },
-                    {
-                        name: "name",
-                        type: "text",
-                        default: null,
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 1,
-                        nullable: true,
-                    },
-                    {
-                        name: "deleted_at",
-                        type: "timestamp",
-                        default: null,
-                        cardinality: 0,
-                        elementtype: null,
-                        table: "my_table",
-                        ordinal: 2,
-                        nullable: true,
-                    },
-                ],
-                uniqueConstraints: [
-                    {
-                        name: "my_table_name_unique",
-                        table: "my_table",
-                        definition:
-                            "CREATE UNIQUE INDEX ON my_table USING btree (name)",
-                        columns: ["name"],
-                        where: "deleted_at IS NULL",
-                    },
-                ],
-                primaryKey: ["id"],
-                foreignKeys: [],
-            }),
-        ).toEqual(
-            unindent`
-            import { type ModelDefinition, type ModelType, sql } from "@casekit/orm";
-
-            export const myTable = {
-                table: "my_table",
-                columns: {
-                    id: {
-                        name: "id",
-                        type: "uuid",
-                        primaryKey: true,
-                        default: sql\`uuid_generate_v4()\`,
-                    },
-                    name: {
-                        name: "name",
-                        type: "text",
-                        unique: { where: sql\`deleted_at IS NULL\` },
-                        nullable: true,
-                    },
-                    deletedAt: { name: "deleted_at", type: "timestamp", nullable: true },
-                },
-            } as const satisfies ModelDefinition;
-
-            export type MyTable = ModelType<typeof myTable>;
-        ` + "\n",
-        );
-    });
-});

package/src/pull/render/renderModel.ts

@@ -1,141 +0,0 @@
-import { camelCase, identity, times, upperFirst } from "lodash-es";
-
-import { ColumnMeta } from "../types/ColumnMeta";
-import { ForeignKey } from "../types/ForeignKey";
-import { UniqueConstraint } from "../types/UniqueConstraint";
-import { format } from "../util/format";
-import { quote } from "../util/quote";
-
-type Definition = {
-    table: string;
-    columns: ColumnMeta[];
-    primaryKey: string[];
-    uniqueConstraints: UniqueConstraint[];
-    foreignKeys: ForeignKey[];
-};
-
-const renderDefault = (d: string) => {
-    return d.match(/^\d+$/)
-        ? `${d}`
-        : d.match(/::text$/)
-          ? d.replace(/::text$/, "")
-          : ["true", "false"].includes(d)
-            ? d
-            : `sql\`${d}\``;
-};
-
-const renderType = (column: ColumnMeta) => {
-    if (column.type === "ARRAY") {
-        return (
-            column.elementtype +
-            times(column.cardinality)
-                .map(() => "[]")
-                .join("")
-        );
-    } else {
-        return column.type;
-    }
-};
-
-export const renderColumn = (def: Definition) => (column: ColumnMeta) => {
-    const primaryKey =
-        def.primaryKey.length === 1 && def.primaryKey[0] === column.name;
-
-    const unique = def.uniqueConstraints.find(
-        (uc) => uc.columns.length === 1 && uc.columns[0] === column.name,
-    );
-
-    const references = def.foreignKeys.find(
-        (fk) =>
-            fk.columnsFrom.length === 1 && fk.columnsFrom[0] === column.name,
-    );
-
-    const definition = [
-        `name: "${column.name}"`,
-        `type: "${renderType(column)}"`,
-        primaryKey ? "primaryKey: true" : null,
-        unique ? `unique: ${renderColumnUniqueConstraint(unique)}` : null,
-        column.nullable ? "nullable: true" : null,
-        column.default ? `default: ${renderDefault(column.default)}` : null,
-        references
-            ? `references: { table: ${quote(references.tableTo)}, column: ${quote(references.columnsTo[0])} }`
-            : null,
-    ]
-        .filter(identity)
-        .join(", ");
-
-    return `"${camelCase(column.name)}": { ${definition} }`;
-};
-
-export const renderColumnUniqueConstraint = (constraint: UniqueConstraint) => {
-    if (constraint.nullsNotDistinct || constraint.where) {
-        return `{${constraint.nullsNotDistinct ? " nullsNotDistinct: true," : ""}${constraint.where ? ` where: sql\`${constraint.where}\`}` : ""}`;
-    } else {
-        return "true";
-    }
-};
-
-export const renderUniqueConstraint = (constraint: UniqueConstraint) => {
-    return `{ columns: [${constraint.columns.map(quote).join(", ")}], ${constraint.where ? `where: sql\`${constraint.where}\`,` : ""} }`;
-};
-
-export const renderUniqueConstraints = (constraints: UniqueConstraint[]) => {
-    return `uniqueConstraints: [ ${constraints.map(renderUniqueConstraint).join(", ")} ]`;
-};
-
-export const renderForeignKey = (constraint: ForeignKey) => {
-    return `{
-        columns: [${constraint.columnsFrom.map(quote).join(", ")}],
-        references: {
-             table: ${quote(constraint.tableTo)},
-             columns: [${constraint.columnsTo.map(quote).join(", ")}]
-        }
-    }`;
-};
-
-export const renderForeignKeys = (constraints: ForeignKey[]) => {
-    return `foreignKeys: [ ${constraints.map(renderForeignKey).join(", ")} ]`;
-};
-
-export const renderModel = async (def: Definition) => {
-    const imports = ["type ModelDefinition", "type ModelType"];
-    if (def.columns.find((c) => c.default !== null)) {
-        imports.push("sql");
-    }
-
-    const lines: string[] = [];
-
-    lines.push(
-        `columns: { ${def.columns.map(renderColumn(def)).join(",\n")} }`,
-    );
-
-    if (def.primaryKey.length > 1) {
-        lines.push(`primaryKey: [${def.primaryKey.map(quote).join(", ")}]`);
-    }
-
-    const multiColumnUniqueConstraints = def.uniqueConstraints.filter(
-        (uc) => uc.columns.length > 1,
-    );
-
-    if (multiColumnUniqueConstraints.length > 0) {
-        lines.push(renderUniqueConstraints(multiColumnUniqueConstraints));
-    }
-
-    const multiColumnForeignKeys = def.foreignKeys.filter(
-        (fk) => fk.columnsFrom.length > 1,
-    );
-
-    if (multiColumnForeignKeys.length > 0) {
-        lines.push(renderForeignKeys(multiColumnForeignKeys));
-    }
-
-    return await format(`
-        import { ${imports.join(", ")} } from "@casekit/orm";
-
-        export const ${camelCase(def.table)} = {
-            table: "${def.table}",
-            ${lines.join(",\n")}
-        } as const satisfies ModelDefinition;
-        
-        export type ${upperFirst(camelCase(def.table))} = ModelType<typeof ${camelCase(def.table)}>;`);
-};

package/src/pull/render/renderModelsIndex.ts

@@ -1,24 +0,0 @@
-import { camelCase } from "lodash-es";
-
-import { format } from "../util/format";
-
-export const renderModelsIndex = async (tableNames: string[]) => {
-    const names = tableNames.map((t) => camelCase(t));
-
-    const imports = names.map(
-        (name) => `import { ${name} } from "./models/${name}.model";`,
-    );
-    const exports = names.map((name) => `${name},`);
-
-    return await format(
-        `
-            ${imports.join("\n")}
-
-            export const models = {
-                ${exports.join("\n")}
-            };
-
-            export type Models = typeof models;
-            `,
-    );
-};

package/src/pull/render/renderRelations.ts

@@ -1,77 +0,0 @@
-import { camelCase, upperFirst } from "lodash-es";
-import pluralize from "pluralize";
-
-import { ForeignKey } from "../types/ForeignKey";
-import { format } from "../util/format";
-import { unquote } from "../util/unquote";
-
-type Definition = {
-    table: string;
-    foreignKeys: Record<string, ForeignKey[]>;
-};
-
-const guessManyToOneRelationName = (fk: ForeignKey) => {
-    if (fk.columnsFrom.length > 1) {
-        return camelCase(fk.columnsFrom.join("_"));
-    } else {
-        return camelCase(fk.columnsFrom[0]).replace(/Id$/, "");
-    }
-};
-
-const guessOneToManyRelationName = (fk: ForeignKey) => {
-    if (fk.columnsFrom.length > 1) {
-        return camelCase(fk.columnsFrom.join("_") + "_" + fk.tableFrom);
-    } else {
-        const foreignName = camelCase(fk.columnsFrom[0]).replace(/Id$/, "");
-        if (foreignName === camelCase(fk.tableTo)) {
-            return camelCase(pluralize(fk.tableFrom));
-        } else {
-            return camelCase(
-                upperFirst(camelCase(fk.columnsFrom[0]).replace(/Id$/, "")) +
-                    " " +
-                    pluralize(fk.tableFrom),
-            );
-        }
-    }
-};
-
-export const renderRelations = async (def: Definition) => {
-    const manyToOne = (def.foreignKeys[def.table] ?? []).map(
-        (fk) =>
-            `${guessManyToOneRelationName(fk)}:` +
-            JSON.stringify({
-                model: camelCase(fk.tableTo),
-                type: "N:1",
-                foreignKey:
-                    fk.columnsFrom.length === 1
-                        ? camelCase(fk.columnsFrom[0])
-                        : fk.columnsFrom.map(camelCase),
-            }),
-    );
-
-    const oneToMany = Object.entries(def.foreignKeys).flatMap(([table, fks]) =>
-        fks
-            .filter((fk) => unquote(fk.tableTo) === unquote(def.table))
-            .map(
-                (fk) =>
-                    `${guessOneToManyRelationName(fk)}:` +
-                    JSON.stringify({
-                        model: camelCase(table),
-                        type: "1:N",
-                        foreignKey:
-                            fk.columnsFrom.length === 1
-                                ? camelCase(fk.columnsFrom[0])
-                                : fk.columnsFrom.map(camelCase),
-                    }),
-            ),
-    );
-
-    return await format(`
-        import { RelationsDefinition } from "@casekit/orm";
-        import { type Models } from "../models";
-
-        export const ${camelCase(def.table)} = {
-            ${[...manyToOne, ...oneToMany].map((rel) => rel).join(",\n")}
-        } as const satisfies RelationsDefinition<Models, "${camelCase(def.table)}">;
-        `);
-};

package/src/pull/render/renderRelationsIndex.ts

@@ -1,24 +0,0 @@
-import { camelCase } from "lodash-es";
-
-import { format } from "../util/format";
-
-export const renderRelationsIndex = async (tableNames: string[]) => {
-    const names = tableNames.map((t) => camelCase(t));
-
-    const imports = names.map(
-        (name) => `import { ${name} } from "./models/${name}.relations";`,
-    );
-    const exports = names.map((name) => `${name},`);
-
-    return await format(
-        `
-            ${imports.join("\n")}
-
-            export const relations = {
-                ${exports.join("\n")}
-            };
-
-            export type Relations = typeof relations;
-            `,
-    );
-};

package/src/pull/types/ColumnMeta.ts

@@ -1,10 +0,0 @@
-export type ColumnMeta = {
-    table: string;
-    name: string;
-    ordinal: number;
-    default: string | null;
-    nullable: boolean;
-    type: string;
-    elementtype: string | null;
-    cardinality: number;
-};

package/src/pull/types/ForeignKey.ts

@@ -1,6 +0,0 @@
-export type ForeignKey = {
-    tableFrom: string;
-    columnsFrom: string[];
-    tableTo: string;
-    columnsTo: string[];
-};

package/src/pull/types/PrimaryKey.ts

@@ -1,6 +0,0 @@
-export type PrimaryKey = {
-    table: string;
-    column: string;
-    name: string;
-    ordinal: number;
-};

package/src/pull/types/UniqueConstraint.ts

@@ -1,8 +0,0 @@
-export type UniqueConstraint = {
-    table: string;
-    definition: string;
-    name: string;
-    columns: string[];
-    where?: string;
-    nullsNotDistinct?: boolean;
-};

package/src/pull/util/format.ts

@@ -1,17 +0,0 @@
-import prettier from "prettier";
-
-export const format = async (source: string) => {
-    try {
-        return await prettier.format(source, {
-            parser: "typescript",
-            printWidth: 80,
-            tabWidth: 4,
-            trailingComma: "all",
-            singleQuote: false,
-            semi: true,
-        });
-    } catch (e) {
-        console.error(e);
-        return source;
-    }
-};

package/src/pull/util/quote.ts

@@ -1,7 +0,0 @@
-import { unquote } from "./unquote";
-
-export const quote = (s: string) => {
-    // we unquote the string first to avoid
-    // double quoting
-    return JSON.stringify(unquote(s));
-};

package/src/pull/util/unquote.ts

@@ -1,9 +0,0 @@
-export const unquote = (s: string) => {
-    // if we're given an quoted string,
-    // strip the quotes
-    if (s.startsWith('"') && s.endsWith('"')) {
-        return s.substring(1, s.length - 1);
-    } else {
-        return s;
-    }
-};

package/src/queries/clauses/IncludeClause.ts

@@ -1,39 +0,0 @@
-import { ModelName } from "../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationsDefinitions } from "../../schema/types/loose/LooseRelationsDefinitions";
-import { FindManyParams } from "../find/types/FindManyParams";
-import { FindOneParams } from "../find/types/FindOneParams";
-
-export type IncludeClause<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-> = {
-    [R in Extract<keyof Relations[M], string>]?: Relations[M][R] extends {
-        model: ModelName<Models>;
-    }
-        ? Relations[M][R] extends { type: "N:1" }
-            ? Omit<
-                  FindOneParams<Models, Relations, Relations[M][R]["model"]>,
-                  // for can only be applied to the top level query
-                  "for"
-              >
-            : Relations[M][R] extends { type: "1:N" }
-              ? Omit<
-                    FindManyParams<Models, Relations, Relations[M][R]["model"]>,
-                    // for can only be applied to the top level query
-                    "for"
-                >
-              : Relations[M][R] extends { type: "N:N" }
-                ? Omit<
-                      FindManyParams<
-                          Models,
-                          Relations,
-                          Relations[M][R]["model"]
-                      >,
-                      // for can only be applied to the top level query
-                      "for"
-                  >
-                : never
-        : never;
-};

package/src/queries/clauses/LateralByClause.ts

@@ -1,4 +0,0 @@
-export type LateralByClause = {
-    column: string;
-    values: unknown[];
-}[];

package/src/queries/clauses/ReturningClause.ts

@@ -1,7 +0,0 @@
-import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { LooseModelDefinition } from "../../schema/types/loose/LooseModelDefinition";
-import { NonEmptyArray } from "../../types/util/NonEmptyArray";
-
-export type ReturningClause<Model extends LooseModelDefinition> = NonEmptyArray<
-    ColumnName<Model>
->;

package/src/queries/clauses/SelectClause.ts

@@ -1,7 +0,0 @@
-import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { LooseModelDefinition } from "../../schema/types/loose/LooseModelDefinition";
-import { NonEmptyArray } from "../../types/util/NonEmptyArray";
-
-export type SelectClause<Model extends LooseModelDefinition> = NonEmptyArray<
-    ColumnName<Model>
->;

package/src/queries/clauses/WhereClause.ts

@@ -1,16 +0,0 @@
-import { ColumnName } from "../../schema/types/helpers/ColumnName";
-import { ModelName } from "../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../schema/types/loose/LooseModelDefinitions";
-import { $and, $not, $or } from "../clauses/where/operators";
-import { WhereClauseValue } from "./where/types/WhereClauseValue";
-
-export type WhereClause<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> = {
-    [C in ColumnName<Models[M]>]?: WhereClauseValue<Models, M, C>;
-} & {
-    [$and]?: WhereClause<Models, M>[];
-    [$or]?: WhereClause<Models, M>[];
-    [$not]?: WhereClause<Models, M>;
-};

package/src/queries/clauses/helpers/OptionalColumn.ts

@@ -1,18 +0,0 @@
-import { ColumnName } from "../../../schema/types/helpers/ColumnName";
-import { HasDefault } from "../../../schema/types/helpers/HasDefault";
-import { IsNullable } from "../../../schema/types/helpers/IsNullable";
-import { IsProvided } from "../../../schema/types/helpers/IsProvided";
-import { IsSerial } from "../../../schema/types/helpers/IsSerial";
-import { LooseModelDefinition } from "../../../schema/types/loose/LooseModelDefinition";
-
-export type OptionalColumn<Model extends LooseModelDefinition> = {
-    [C in ColumnName<Model>]: IsNullable<Model, C> extends true
-        ? C
-        : IsSerial<Model, C> extends true
-          ? C
-          : HasDefault<Model, C> extends true
-            ? C
-            : IsProvided<Model, C> extends true
-              ? C
-              : never;
-}[ColumnName<Model>];

package/src/queries/clauses/helpers/OptionalParams.ts

@@ -1,14 +0,0 @@
-import { ColumnType } from "../../../schema/types/helpers/ColumnType";
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { OptionalColumn } from "./OptionalColumn";
-
-export type OptionalParams<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> =
-    OptionalColumn<Models[M]> extends never
-        ? unknown
-        : {
-              [C in OptionalColumn<Models[M]>]?: ColumnType<Models, M, C>;
-          };

package/src/queries/clauses/helpers/RequiredColumn.ts

@@ -1,8 +0,0 @@
-import { ColumnName } from "../../../schema/types/helpers/ColumnName";
-import { LooseModelDefinition } from "../../../schema/types/loose/LooseModelDefinition";
-import { OptionalColumn } from "./OptionalColumn";
-
-export type RequiredColumn<Model extends LooseModelDefinition> = Exclude<
-    ColumnName<Model>,
-    OptionalColumn<Model>
->;

package/src/queries/clauses/helpers/RequiredParams.ts

@@ -1,14 +0,0 @@
-import { ColumnType } from "../../../schema/types/helpers/ColumnType";
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { RequiredColumn } from "./RequiredColumn";
-
-export type RequiredParams<
-    Models extends LooseModelDefinitions,
-    M extends ModelName<Models>,
-> =
-    RequiredColumn<Models[M]> extends never
-        ? unknown
-        : {
-              [C in RequiredColumn<Models[M]>]: ColumnType<Models, M, C>;
-          };

package/src/queries/clauses/include/IncludedRelationModel.ts

@@ -1,13 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationDefinition } from "../../../schema/types/loose/LooseRelationDefinition";
-import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
-
-export type IncludedRelationModel<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-    R extends keyof Relations[M],
-> = Relations[M][R] extends LooseRelationDefinition
-    ? Extract<Relations[M][R]["model"], ModelName<Models>>
-    : never;

package/src/queries/clauses/include/IncludedRelationName.ts

@@ -1,11 +0,0 @@
-import { ModelName } from "../../../schema/types/helpers/ModelName";
-import { LooseModelDefinitions } from "../../../schema/types/loose/LooseModelDefinitions";
-import { LooseRelationsDefinitions } from "../../../schema/types/loose/LooseRelationsDefinitions";
-import { FindManyParams } from "../../find/types/FindManyParams";
-
-export type IncludedRelationName<
-    Models extends LooseModelDefinitions,
-    Relations extends LooseRelationsDefinitions<Models>,
-    M extends ModelName<Models>,
-    Q extends FindManyParams<Models, Relations, M>,
-> = keyof Relations[M] & keyof Q["include"];