@apisr/drizzle-model 0.0.1

package/tests/insert.test.ts

@@ -0,0 +1,233 @@
+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 { eq, inArray } from "drizzle-orm";
+import { esc } from "@/model/query/operations";
+
+const model = modelBuilder({
+  schema,
+  db,
+  relations,
+  dialect: "PostgreSQL",
+});
+
+const postsModel = model("userPosts", {});
+const userModel = model("user", {});
+
+function sortById<T extends { id: number }>(rows: T[]) {
+  return [...rows].sort((a, b) => a.id - b.id);
+}
+
+describe("Model Update/Delete/Upsert Test", () => {
+  test(".update | updates a single post", async () => {
+    const [seed] = (await postsModel.insert({
+      title: "Update seed",
+      featured: false,
+      userId: 1,
+    }).return()) as any[];
+
+    const updated = await postsModel
+      .where({ id: esc(seed.id) })
+      .update({
+        title: "Updated title",
+        featured: true,
+      })
+      .return();
+
+    const expected = await db
+      .select()
+      .from(schema.userPosts)
+      .where(eq(schema.userPosts.id, seed.id));
+
+    expect(updated).toBeArray();
+    expect((updated as any[])[0].id).toBe(seed.id);
+    expect((updated as any[])[0].title).toBe("Updated title");
+    expect((updated as any[])[0].featured).toBe(true);
+    expect((updated as any[])[0]).toEqual((expected as any[])[0]);
+  });
+
+  test(".delete | deletes a single post", async () => {
+    const [seed] = (await postsModel.insert({
+      title: "Delete seed",
+      featured: null,
+      userId: 1,
+    }).return()) as any[];
+
+    const deleted = await postsModel
+      .where({ id: esc(seed.id) })
+      .delete()
+      .return();
+
+    const expectedDeleted = await db
+      .select()
+      .from(schema.userPosts)
+      .where(eq(schema.userPosts.id, seed.id));
+
+    expect(deleted).toBeArray();
+    expect((deleted as any[])[0].id).toBe(seed.id);
+    expect(expectedDeleted).toHaveLength(0);
+  });
+
+  test(".upsert | inserts then updates by unique email", async () => {
+    const uniq = `${Date.now()}-${Math.random()}`;
+    const email = `upsert-${uniq}@example.com`;
+
+    const [created] = (await userModel.upsert({
+      insert: {
+        name: "Upsert user",
+        email,
+        age: 10,
+        isVerified: false,
+      },
+      update: {
+        name: "Upsert user updated",
+      },
+      target: schema.user.email as any,
+    }).return()) as any[];
+
+    const [updated] = (await userModel.upsert({
+      insert: {
+        name: "Upsert user (ignored)",
+        email,
+        age: 10,
+        isVerified: false,
+      },
+      update: {
+        name: "Upsert user updated",
+      },
+      target: schema.user.email as any,
+    }).return()) as any[];
+
+    const expected = await db
+      .select()
+      .from(schema.user)
+      .where(eq(schema.user.email, email));
+
+    expect(created).toBeDefined();
+    expect(updated).toBeDefined();
+    expect(updated.id).toBe(created.id);
+    expect(updated.name).toBe("Upsert user updated");
+    expect(updated).toEqual((expected as any[])[0]);
+  });
+});
+
+// Returns new model
+// postsModel.extend({
+//   query: {
+//     userId: 123,
+//   },
+// });
+
+// const userModel = model({
+//   table: userTable,
+//   db,
+// });
+
+describe("Model Insert Test", () => {
+  test(".insert | one entry", async () => {
+    const inserted: any = await postsModel.insert({
+      title: "Hello world!",
+      featured: true,
+      userId: 1,
+    }).return();
+
+    const expected = await db
+      .select()
+      .from(schema.userPosts)
+      .where(eq(schema.userPosts.id, (inserted as any[])[0].id));
+
+    console.dir(inserted, {
+      depth: null,
+    });
+
+    expect(inserted).toBeDefined();
+    expect(Array.isArray(inserted)).toBe(true);
+    expect((inserted as any[])[0]).toBeDefined();
+    expect((inserted as any[])[0].title).toBe("Hello world!");
+    expect((inserted as any[])[0].featured).toBe(true);
+    expect((inserted as any[])[0].userId).toBe(1);
+    expect((inserted as any[])[0].likes).toBe(0);
+    expect((inserted as any[])[0].views).toBe(0);
+    expect((inserted as any[])[0]).toEqual((expected as any[])[0]);
+  });
+
+  test(".insert | one entry with defaults", async () => {
+    const inserted: any = await postsModel.insert({
+      title: "Post with defaults",
+      userId: 1,
+    }).return();
+
+    const expected = await db
+      .select()
+      .from(schema.userPosts)
+      .where(eq(schema.userPosts.id, (inserted as any[])[0].id));
+
+    console.dir(inserted, {
+      depth: null,
+    });
+
+    expect(inserted).toBeDefined();
+    expect(Array.isArray(inserted)).toBe(true);
+    expect((inserted as any[])[0]).toBeDefined();
+    expect((inserted as any[])[0].title).toBe("Post with defaults");
+    expect((inserted as any[])[0].userId).toBe(1);
+
+    // description and featured are optional
+    expect((inserted as any[])[0].description).toBeNull();
+    expect((inserted as any[])[0].featured).toBeNull();
+
+    // likes and views should use table defaults
+    expect((inserted as any[])[0].likes).toBe(0);
+    expect((inserted as any[])[0].views).toBe(0);
+    expect((inserted as any[])[0]).toEqual((expected as any[])[0]);
+  });
+
+  test(".insert | multiple entries", async () => {
+    const inserted = await postsModel.insert([
+      {
+        title: "First bulk post",
+        description: "First bulk description",
+        featured: false,
+        userId: 1,
+      },
+      {
+        title: "Second bulk post",
+        description: "Second bulk description",
+        featured: true,
+        userId: 1,
+      },
+    ]).return();
+
+    const ids = (inserted as any[]).map((x) => x.id);
+    const expected = await db
+      .select()
+      .from(schema.userPosts)
+      .where(inArray(schema.userPosts.id, ids));
+
+    console.dir(inserted, {
+      depth: null,
+    });
+
+    expect(inserted).toBeDefined();
+    expect(Array.isArray(inserted)).toBe(true);
+    expect(inserted as any[]).toHaveLength(2);
+
+    const [first, second] = inserted as any[];
+
+    expect(first.title).toBe("First bulk post");
+    expect(first.description).toBe("First bulk description");
+    expect(first.featured).toBe(false);
+    expect(first.likes).toBe(0);
+    expect(first.views).toBe(0);
+
+    expect(second.title).toBe("Second bulk post");
+    expect(second.description).toBe("Second bulk description");
+    expect(second.featured).toBe(true);
+    expect(second.likes).toBe(0);
+    expect(second.views).toBe(0);
+
+    expect(sortById(inserted as any)).toEqual(sortById(expected as any));
+  });
+});

package/tests/relations.ts

@@ -0,0 +1,38 @@
+import * as schema from "./schema";
+import { defineRelations } from "drizzle-orm";
+// schema.
+export const relations = defineRelations(schema, (r) => ({
+  user: {
+    posts: r.many.userPosts(),
+    invitee: r.one.user({
+      from: r.user.invitedBy,
+      to: r.user.id,
+    }),
+  },
+  userPosts: {
+    user: r.one.user({
+      from: r.userPosts.userId,
+      to: r.user.id,
+    }),
+    comments: r.many.postComments({
+      from: r.userPosts.id,
+      to: r.postComments.postId,
+    }),
+  },
+  postComments: {
+    author: r.one.user({
+      from: r.postComments.authorId,
+      to: r.user.id,
+    }),
+    post: r.one.userPosts({
+      from: r.postComments.postId,
+      to: r.userPosts.id,
+    }),
+  },
+  userIdeas: {
+    user: r.one.user({
+      from: r.userIdeas.userId,
+      to: r.user.id,
+    }),
+  }
+}));

package/tests/schema.ts

@@ -0,0 +1,49 @@
+import { pgTable, integer, text, boolean } from "drizzle-orm/pg-core";
+
+// --- TABLES ---
+
+export const user = pgTable("user", {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  name: text("name").notNull(),
+  email: text("email").unique().notNull(),
+  age: integer().notNull().default(0),
+  isVerified: boolean("is_verified"),
+  invitedBy: integer("invited_by"),
+  secretField: integer("secret_field").default(0),
+});
+
+export const userPosts = pgTable("user_posts", {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  title: text("title").notNull(),
+  description: text("description"),
+  likes: integer().notNull().default(0),
+  views: integer().notNull().default(0),
+  featured: boolean("featured"),
+
+  // Foreign Key
+  userId: integer("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const postComments = pgTable("user_post_comments", {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  content: text("content"),
+
+  // Foreign Keys
+  authorId: integer("author_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  postId: integer("post_id")
+    .notNull()
+    .references(() => userPosts.id, { onDelete: "cascade" }),
+});
+
+
+export const userIdeas = pgTable("user_ideas", {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  content: text("content"),
+  userId: integer("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    "preserveSymlinks": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	entry: "./src/index.ts",
+	dts: true,
+	format: "esm",
+	outDir: "./dist",
+	clean: true,
+	unbundle: true,
+	noExternal: [/@apisr\/.*/],
+	external: ["drizzle-kit", "drizzle-orm"],
+});