@apisr/drizzle-model 0.0.3 → 2.0.0

package/DISCLAIMER.md

@@ -0,0 +1,5 @@
+# DISCLAIMER
+
+### What is still not in package
+- Custom columns (Still not planned)
+- Views (Still not planned)

package/TODO.md

@@ -1,64 +1,11 @@
-- * Add all essential functions as `update`, `insert`, `delete`, `findMany`, `findFirst`
-- Make `route` function (Just duplicate):
-```ts
-const [val1, val2] = await userModel.name({
-  like: "A%"
-}).route(
-  (userModel) => userModel.isVerified(true).findMany(),
-  (userModel) => userModel.isVerified(false).age({
-    lte: 18
-  }).findMany()
-  // ...args[]
-)
-```
-- Make built in `paginate` which is pagination function, used as:
-```ts
-const userModel = model({
-  table: userTable,
-  
-  // Optional
-  pagination: {
-    max: 10
-  }
-})
+# TODO:
 
-const page = 1;
-
-userModel.name({
-  like: "A%"
-}).userId(userId).paginate(page)
-```
-* Make built in `upsert`, as:
+- DONE TYPES => `count()` function to count rows
+- DONE => Fix types. On insert, and add Simplify<> = for more readable queries.
+- DONE TYPES => add `returnFirst()` to return first of `return()`
+- DONE TYPES => add `omit()` as progammic `exclude()`. The main difference is `omit()` is applied after query. `exclude()` is applied on the query.
+- JUST remake a entire core. Manually write code with a few AI changes.
+- DONE TYPES => Add `safe()`:
 ```ts
-userModel.id(123).upsert({
-  // create obj
-}, {
-  // update obj 
-}, /* options */)
-```
-
-* Transactions:
-```ts
-userModel.transaction(tx => ...);
-
-// With other models
-userModel.transaction(tx => {
-  postsModel.db(tx).insert({
-    userId: 123,
-    content: ...
-  })
-  
-  // or
-  
-  const txPostsModel = postsModel.db(tx);
-  
-  txPostsModel.insert({
-    userId: 123,
-    content: ...
-  })
-  
-  txPostsModel.userId(123).delete()
-});
+const { data: user, error } = userModel.findFirst().safe();
 ```
-- / Soft delete?
-- * Dialect based configuration `mysql`, `pgsql` and etc... like `returning()` on pgsql and `$returningId()` on mysql

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apisr/drizzle-model",
-  "version": "0.0.3",
+  "version": "2.0.0",
   "private": false,
   "scripts": {
     "lint": "eslint . --max-warnings 0",
@@ -13,6 +13,7 @@
   "devDependencies": {
     "@repo/eslint-config": "*",
     "@repo/typescript-config": "*",
+    "@apisr/logger": "^0.0.3",
     "@types/bun": "latest",
     "@types/node": "^22.15.3",
     "@types/pg": "^8.15.6",

package/src/core/dialect.ts

@@ -0,0 +1,81 @@
+import type { ModelDialect } from "../model/dialect.ts";
+
+/** Alias for a generic record with string keys. */
+type AnyRecord = Record<string, unknown>;
+
+/**
+ * Encapsulates dialect-specific logic for different SQL databases.
+ *
+ * Provides helpers for determining returning-id behaviour and
+ * lazily importing the correct Drizzle `alias()` function based on the dialect.
+ */
+export class DialectHelper {
+	/** The dialect string identifying the target database engine. */
+	readonly dialect: ModelDialect;
+
+	constructor(dialect: ModelDialect) {
+		this.dialect = dialect;
+	}
+
+	/**
+	 * Returns `true` when the dialect only supports `$returningId()`
+	 * instead of the standard `.returning()` method.
+	 *
+	 * Applies to MySQL, SingleStore and CockroachDB.
+	 */
+	isReturningIdOnly(): boolean {
+		return (
+			this.dialect === "MySQL" ||
+			this.dialect === "SingleStore" ||
+			this.dialect === "CockroachDB"
+		);
+	}
+
+	/**
+	 * Creates a table alias using the dialect-specific Drizzle module.
+	 *
+	 * Dynamically imports the correct `alias` utility so the core
+	 * does not carry a hard dependency on every dialect.
+	 *
+	 * @param table - The Drizzle table object to alias.
+	 * @param aliasName - The SQL alias name.
+	 * @returns The aliased table, or the original table if aliasing is unavailable.
+	 */
+	async createTableAlias(
+		table: AnyRecord,
+		aliasName: string
+	): Promise<AnyRecord> {
+		const modulePath = this.getDialectModulePath();
+		if (!modulePath) {
+			return table;
+		}
+
+		const mod: AnyRecord = await import(modulePath);
+		if (typeof mod.alias === "function") {
+			return (mod.alias as (t: AnyRecord, name: string) => AnyRecord)(
+				table,
+				aliasName
+			);
+		}
+
+		return table;
+	}
+
+	/**
+	 * Resolves the Drizzle ORM module path for the current dialect.
+	 *
+	 * @returns The import specifier, or `undefined` for unsupported dialects.
+	 */
+	private getDialectModulePath(): string | undefined {
+		switch (this.dialect) {
+			case "PostgreSQL":
+				return "drizzle-orm/pg-core";
+			case "MySQL":
+				return "drizzle-orm/mysql-core";
+			case "SQLite":
+				return "drizzle-orm/sqlite-core";
+			default:
+				return undefined;
+		}
+	}
+}

package/src/core/index.ts

@@ -0,0 +1,24 @@
+// Core v2 — public API
+export { DialectHelper } from "./dialect.ts";
+export { QueryError } from "./query/error.ts";
+export {
+	JoinExecutor,
+	type JoinExecutorConfig,
+	type JoinNode,
+} from "./query/joins.ts";
+export {
+	ProjectionBuilder,
+	type ProjectionResult,
+} from "./query/projection.ts";
+export { WhereCompiler } from "./query/where.ts";
+export {
+	type MutateKind,
+	MutateResult,
+	type MutateState,
+	QueryResult,
+	type QueryState,
+	type SafeResult,
+	ThenableResult,
+} from "./result.ts";
+export { ModelRuntime, type ModelRuntimeConfig } from "./runtime.ts";
+export { ResultTransformer } from "./transform.ts";

package/src/core/query/error.ts

@@ -0,0 +1,15 @@
+/**
+ * Represents an error that occurred during query compilation or execution.
+ *
+ * Extends the native `Error` class so it can be caught independently
+ * from generic runtime errors.
+ */
+export class QueryError extends Error {
+	/** Discriminator for runtime type checks. */
+	readonly kind = "QueryError" as const;
+
+	constructor(message: string, options?: ErrorOptions) {
+		super(message, options);
+		this.name = "QueryError";
+	}
+}