@apisr/drizzle-model 0.0.1

package/tests/builder-v2.type-test.ts

@@ -0,0 +1,343 @@
+import * as schema from "./schema";
+import { db } from "./db";
+import { relations } from "./relations";
+import { modelBuilder } from "src/model";
+import { gte, sql, eq, or } from "drizzle-orm";
+import { esc } from "@/model/query/operations";
+
+const model = modelBuilder({
+  schema,
+  db,
+  relations,
+  dialect: "PostgreSQL"
+});
+
+const userModel = model("user", {
+  methods: {
+    whereName(name: string) {
+      return userModel.where({
+        name: esc(eq, name)
+      });
+    },
+    findByName(name: string) {
+      return userModel
+        .where({
+          name: esc(name)
+        })
+        .findFirst()
+        .select({
+          id: true,
+          name: true
+        });
+    }
+  },
+  format: ({ secretField, ...rest }) => ({
+    ...rest,
+    customField: "123"
+  })
+});
+const userIdeasModel = model("userIdeas", {});
+
+// userModel.
+// userModel.
+
+// userModel.
+
+const testRaw = await userModel
+  .where({
+    id: {
+      or: [
+        esc(1),
+        esc(2),
+      ]
+    }
+  })
+  .findFirst()
+  .with({
+    posts: {
+      comments: true,
+    },
+  })
+  .select({
+    age: true,
+    posts: {
+      title: true,
+      comments: {
+        content: true,
+      },
+    },
+  });
+
+// testRaw.posts[0]?.comments[0]?.content;
+const testRaw1 = await userModel
+  .where({
+    age: esc(12)
+  })
+  .findFirst()
+  .with({
+    posts: {
+      comments: true,
+    },
+  })
+  .exclude({
+    age: true,
+    posts: {
+      id: true,
+      comments: {
+        content: true,
+      },
+    },
+  });
+
+// testRaw1.posts[0]?.comments[0].;
+
+const postsModel = model("userPosts", {});
+const commentsModel = model("postComments", {});
+
+const testRaw2 = await userModel
+  .where({
+    age: esc(12)
+  })
+  .findFirst()
+  .with({
+    // Fix is relations in here are from userModel not from posts
+    posts: postsModel.where({
+      id: esc(12)
+    }).include({
+      comments: true,
+    }),
+  });
+
+// testRaw2.posts[0]?.comments;
+
+const testRaw3 = await userModel
+  .where({
+    id: {
+      or: [
+        {
+          equal: 1,
+        },
+        esc(12),
+      ],
+    }
+  })
+  .findFirst()
+  .with({
+    // Fix is relations in here are from userModel not from posts
+    posts: postsModel
+      .where({
+        id: esc(12)
+      })
+      .include({
+        comments: commentsModel.where({ id: esc(12) }).include({
+          author: true
+        }),
+      }),
+  });
+
+// testRaw3.posts[0]?.comments[0]?.author;
+
+const testRaw4 = await userModel
+  .where({
+    age: {
+      or: [
+        {
+          equal: 1,
+        },
+        esc(2),
+      ],
+    }
+  })
+  .findMany()
+  .with({
+    // Fix is relations in here are from userModel not from posts
+    posts: postsModel
+      .where({
+        id: esc(12)
+      })
+      .include({
+        comments: true,
+      }),
+  })
+  .select({
+    posts: {
+      description: true,
+      comments: true,
+    },
+  });
+
+// testRaw4[0]?.posts[0].
+
+const testRaw5 = await userModel
+  .where({
+    age: {
+      or: [
+        {
+          equal: 1,
+        },
+        esc(12),
+      ]
+    },
+  })
+  .findMany()
+  .with({
+    // Fix is relations in here are from userModel not from posts
+    posts: postsModel
+      .where({
+        id: esc(12)
+      })
+      .include({
+        comments: true,
+      }),
+  })
+  .exclude({
+    posts: {
+      description: true,
+      comments: true,
+    },
+  });
+
+// testRaw5[0]?.posts[0].
+
+const testRaw6 = await userModel
+  .insert({
+    email: "email@email",
+    name: "Nameie",
+    age: 123,
+  })
+  .return();
+
+// testRaw6.
+
+// testRaw6.
+
+// testRaw6.
+
+const testRaw7 = await userModel
+  .where({ id: esc(12) })
+  .update({
+    age: 12
+  })
+  .return();
+
+// testRaw7?.[0]?.;
+
+const testRaw8 = await userModel
+  .where({ id: esc(12) })
+  .delete()
+  .return();
+
+// testRaw8[0].
+
+// postsModel.
+
+const testRaw9 = await postsModel
+  .where({
+    user: {
+      id: esc(12)
+    },
+  })
+  .update({
+    description: ""
+  })
+  .return();
+
+const testRaw10 = await postsModel
+  .where(
+    userModel.where({ id: esc(12) })
+  )
+  .update({
+    description: ""
+  })
+  .return();
+
+const testRaw11 = await postsModel
+  .where(
+    sql``
+  )
+  .update({
+    description: ""
+  })
+  .return();
+
+// testRaw11[0].
+
+const testRaw12 = await postsModel
+  .where(
+    gte(schema.postComments.id, 123)
+  )
+  .update({
+    description: ""
+  })
+  .return();
+
+db.transaction(async tx => {
+  const result = await postsModel
+    .db(tx)
+    .where(
+      gte(schema.postComments.id, 123)
+    )
+    .update({
+      description: ""
+    })
+    .return({
+      id: true
+    });
+});
+
+const testRaw13 = await userModel.whereName("Alex").findFirst();
+const testRaw14 = await userModel.findByName("Alex");
+// testRaw13.
+// testRaw14.
+
+// userModel.$form.methods.
+
+// userModel.w
+
+const testRaw15 = await userModel
+  .where({
+    name: esc("Alex"),
+  })
+  .findFirst()
+  .raw();
+
+const userModel2 = userModel.extend({
+  methods: {
+    whereName(name: string) {
+      return userModel2.where({
+        name: esc(name)
+      });
+    }
+  },
+  format: (output) => {
+    return {
+      ...output,
+      isJoke: true
+    };
+  }
+});
+
+const testRaw16 = await userModel2.upsert({
+  insert: {
+    email: "123",
+    name: "123",
+    age: 123,
+  },
+  update: (c) => ({
+    name: c.inserted("name")
+  }),
+  updateWhere: (c) => ({
+    name: {
+      not: c.excluded("name")
+    }
+  }),
+  target: ["id"]
+}).return({
+  age: true
+});
+
+// testRaw16.
+
+// testRaw16.
+
+// userModel2.

package/tests/builder.test.ts

@@ -0,0 +1,63 @@
+import { modelBuilder } from "../src";
+import * as schema from "./schema";
+import { db } from "./db";
+import { relations } from "./relations";
+
+const model = modelBuilder({
+	schema,
+	db,
+	relations,
+});
+
+const userModel = model("user", {});
+const postsModel = model("userPosts", {});
+const commentsModel = model("postComments", {});
+
+const testRaw1 = await userModel
+	.age(123)
+	.findOne()
+	.with({
+		// Fix is relations in here are from userModel not from posts
+		posts: postsModel.id(123),
+	});
+
+testRaw1.posts;
+
+const testRaw2 = await userModel
+	.age(123)
+	.findOne()
+	.with({
+		posts: true,
+	})
+	.select({
+		age: true,
+		email: true,
+		posts: {
+			id: true,
+		},
+	});
+
+// testRaw2.posts[0]?.id
+
+const testRaw3 = await userModel.age(123).findOne().with({
+	invitee: true,
+});
+
+const testRaw4 = await postsModel.id(1).findOne().with({
+	user: true,
+});
+
+const testRaw5 = await userModel
+	.age(123)
+	.findOne()
+	.with({
+		posts: true,
+	})
+	.select({
+		age: true,
+		email: true,
+		posts: {
+			id: true,
+		},
+	});
+// testRaw4.user.

package/tests/db.ts

@@ -0,0 +1,25 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+// import { drizzle as drizzleMysql } from "drizzle-orm/mysql2";
+import * as schema from "./schema";
+import { relations } from "./relations";
+
+// export const mysqlDb = drizzleMysql("nothing");
+
+// mysqlDb.insert().values().$returningId;
+
+export const db = drizzle(process.env.DATABASE_URL!, {
+  schema,
+  relations,
+});
+
+// db.transaction
+
+// db.select().from().where
+
+// db.query.user.findFirst({
+//   with: {
+//     posts: {
+//       with: {},
+//     },
+//   },
+// });

package/tests/find.test.ts

@@ -0,0 +1,155 @@
+import { modelBuilder } from "../src";
+import * as schema from "./schema";
+import { db } from "./db";
+import { relations } from "./relations";
+import { test, describe, expect } from "bun:test";
+import { esc } from "@/model/query/operations";
+import { and, eq, gte, like, or } from "drizzle-orm";
+
+const model = modelBuilder({
+  schema,
+  db,
+  relations,
+  dialect: "PostgreSQL",
+});
+
+const userModel = model("user", {});
+
+async function rawUsers(where?: any) {
+  if (where) {
+    return await db.select().from(schema.user).where(where);
+  }
+  return await db.select().from(schema.user);
+}
+
+function sortById<T extends { id: number }>(rows: T[]) {
+  return [...rows].sort((a, b) => a.id - b.id);
+}
+
+describe("Model Find Test", () => {
+  test(".find | one filter", async () => {
+    // Eq to:
+    // await db.select().from(userTable).where(eq(userTable.name, "Alex"));
+    const raw = await userModel.where({ name: esc("Alex") }).findMany();
+
+    const expected = await rawUsers(eq(schema.user.name, "Alex"));
+
+    console.dir(raw, {
+      depth: null,
+    });
+
+    expect(raw).toBeArray();
+    expect(raw[0]).toBeDefined();
+    expect(sortById(raw as any)).toEqual(sortById(expected as any));
+  });
+
+  test(".find | no filters returns all users", async () => {
+    const raw = await userModel.findMany();
+
+    const expected = await rawUsers();
+
+    expect(raw).toBeArray();
+    expect(raw).toHaveLength((expected as any[]).length);
+    expect(sortById(raw as any)).toEqual(sortById(expected as any));
+  });
+
+  test(".find | multiple filters", async () => {
+    const raw = await userModel.where({
+      name: esc("Alex"),
+      isVerified: esc(false),
+      age: esc(12),
+    }).findMany();
+
+    const expected = await rawUsers(and(
+      eq(schema.user.name, "Alex"),
+      eq(schema.user.isVerified, false),
+      eq(schema.user.age, 12),
+    ));
+
+    console.dir(raw, {
+      depth: null,
+    });
+
+    expect(raw).toBeArray();
+    expect(raw[0]).toBeDefined();
+    expect(sortById(raw as any)).toEqual(sortById(expected as any));
+  });
+
+  test(".find | complex filters 01", async () => {
+    const raw = await userModel.where({
+      name: {
+        or: [esc("Alex"), esc("Dino")],
+      },
+    }).findMany();
+
+    const expected = await rawUsers(or(
+      eq(schema.user.name, "Alex"),
+      eq(schema.user.name, "Dino"),
+    ));
+
+    console.dir(raw, {
+      depth: null,
+    });
+
+    expect(raw).toBeArray();
+    expect(raw[0]).toBeDefined();
+    expect(sortById(raw as any)).toEqual(sortById(expected as any));
+  });
+
+  test(".find | complex filters 02", async () => {
+    const raw = await userModel.where({
+      name: {
+        or: [esc("Alex"), esc("Dino"), esc("Anna")],
+      },
+      age: {
+        gte: esc(18),
+      },
+    }).findMany();
+
+    const expected = await rawUsers(and(
+      or(
+        eq(schema.user.name, "Alex"),
+        eq(schema.user.name, "Dino"),
+        eq(schema.user.name, "Anna"),
+      ),
+      gte(schema.user.age, 18),
+    ));
+
+    console.dir(raw, {
+      depth: null,
+    });
+
+    expect(raw).toBeArray();
+    expect(raw[0]).toBeDefined();
+    expect(sortById(raw as any)).toEqual(sortById(expected as any));
+  });
+
+  test(".find | complex filters 03", async () => {
+    const raw = await userModel.where({
+      name: {
+        like: esc("A%"),
+      },
+    }).findMany();
+
+    const expected = await rawUsers(like(schema.user.name, "A%"));
+
+    console.dir(raw, {
+      depth: null,
+    });
+
+    expect(raw).toBeArray();
+    expect(raw[0]).toBeDefined();
+    expect(sortById(raw as any)).toEqual(sortById(expected as any));
+  });
+
+  test(".findOne | returns a single matching user", async () => {
+    const anna = await userModel.where({ name: esc("Anna") }).findFirst();
+
+    const expected = (await rawUsers(eq(schema.user.name, "Anna")))[0];
+
+    expect(anna).toBeDefined();
+    expect((anna as any).id).toBe(5);
+    expect(anna?.email).toBe("an.na@example.com");
+    expect(anna as any).toEqual(expected as any);
+  });
+});