@apisr/drizzle-model 0.0.1

package/src/model/relation.ts

@@ -0,0 +1,121 @@
+import type {
+  TableRelationalConfig,
+  TablesRelationalConfig,
+} from "drizzle-orm/relations";
+import type { ModelIdentifier } from "./model.ts";
+import type { IsTable, TableOutput } from "./table.ts";
+import type { RecursiveBooleanRecord } from "../types.ts";
+
+/**
+ * Defines the cardinality of a relation: "one" (hasOne) or "many" (hasMany).
+ */
+export type RelationKind = "one" | "many";
+
+/**
+ * Utility type to wrap a type T in an array if the relation kind is "many",
+ * otherwise returns T as is.
+ *
+ * @typeParam Kind - "one" or "many"
+ * @typeParam T - The type to potentially wrap
+ */
+export type ApplyRelationCardinality<
+  Kind extends RelationKind,
+  T,
+> = Kind extends "many" ? T[] : T;
+
+/**
+ * Extracts the metadata for a specific relation from a table's configuration.
+ *
+ * @typeParam TTable - Relational configuration for the table
+ * @typeParam Key - Name of the relation field
+ */
+export type RelationMeta<
+  TTable extends TableRelationalConfig,
+  Key extends string,
+> = TTable["relations"][Key];
+
+/**
+ * Resolves the configuration of the target table in a relation.
+ *
+ * @typeParam TSchema - Full relational schema
+ * @typeParam Meta - Metadata object containing the target table name
+ */
+export type TargetTable<
+  TSchema extends TablesRelationalConfig,
+  Meta extends { targetTableName: string; },
+> = TSchema[Meta["targetTableName"]];
+
+/**
+ * Resolves the raw row type of a related table.
+ *
+ * @typeParam Key - Name of the relation
+ * @typeParam TSchema - Full relational schema
+ * @typeParam TTable - Relational configuration for the source table
+ */
+export type RelationTargetRow<
+  Key extends string,
+  TSchema extends TablesRelationalConfig,
+  TTable extends TableRelationalConfig,
+> = TableOutput<
+  IsTable<TargetTable<TSchema, RelationMeta<TTable, Key>>["table"]>
+>;
+
+/**
+ * Resolves the type of a single relation field based on the selection value.
+ *
+ * If the value is a nested selection object, it recursively resolves that selection
+ * and merges it with the target row type.
+ * Finally, it applies the correct cardinality (array or single object).
+ *
+ * @typeParam Key - Name of the relation
+ * @typeParam Value - The selection value (boolean or nested object)
+ * @typeParam TSchema - Full relational schema
+ * @typeParam TTable - Relational configuration for the source table
+ */
+export type ResolveSingleRelation<
+  Key extends string,
+  Value,
+  TSchema extends TablesRelationalConfig,
+  TTable extends TableRelationalConfig,
+> = Value extends Record<string, any>
+  ? ApplyRelationCardinality<
+    RelationMeta<TTable, Key>["relationType"],
+    ResolveRelationSelection<
+      Value,
+      TSchema,
+      TargetTable<TSchema, RelationMeta<TTable, Key>>
+    > &
+    RelationTargetRow<Key, TSchema, TTable>
+  >
+  : ApplyRelationCardinality<
+    RelationMeta<TTable, Key>["relationType"],
+    RelationTargetRow<Key, TSchema, TTable>
+  >;
+
+/**
+ * Recursively resolves a selection object into a typed result object.
+ *
+ * Iterates over keys in the selection that are true or objects, resolving
+ * each relation and building the final output type.
+ *
+ * @typeParam TSelection - The selection object passed to .with()
+ * @typeParam TSchema - Full relational schema
+ * @typeParam TTable - Relational configuration for the current table
+ */
+export type ResolveRelationSelection<
+  TSelection extends Record<string, any>,
+  TSchema extends TablesRelationalConfig,
+  TTable extends TableRelationalConfig,
+> = {
+    [Key in keyof TSelection as TSelection[Key] extends
+    | true
+    | RecursiveBooleanRecord
+    | ModelIdentifier<any>
+    ? Key & string
+    : never]: ResolveSingleRelation<
+      Key & string,
+      TSelection[Key],
+      TSchema,
+      TTable
+    >;
+  };

package/src/model/result.ts

@@ -0,0 +1,91 @@
+import type {
+  TableRelationalConfig,
+  TablesRelationalConfig,
+} from "drizzle-orm/relations";
+import type { MethodWithResult, MethodWithValue } from "./methods/with.ts";
+import type { MethodSelectResult, MethodSelectValue } from "./methods/select.ts";
+import type {
+  MethodExcludeResult,
+  MethodExcludeValue,
+} from "./methods/exclude.ts";
+import type { MethodReturnResult } from "./methods/return.ts";
+import type { ReturningIdDialects } from "./dialect.ts";
+import type { TableOutput } from "./table.ts";
+import type { ModelConfig } from "./config.ts";
+import type { ResolveOptionsFormat } from "./options.ts";
+import type { ModelFormatValue } from "./format.ts";
+
+/**
+ * Represents the result of a model operation (like findMany or findFirst).
+ *
+ * It extends Promise to be awaitable, returning the result data.
+ * It also exposes a `.with()` method for chaining relation loading.
+ *
+ * @typeParam TResult - The type of the data returned (e.g. Row[])
+ * @typeParam TSchema - Full relational schema
+ * @typeParam TTable - Relational configuration for the current table
+ */
+export interface ModelQueryResult<
+  TResult extends Record<string, any>,
+  TConfig extends ModelConfig,
+  TExcludedKeys extends string = string,
+  TSchema extends TablesRelationalConfig = TConfig["schema"],
+  TTable extends TableRelationalConfig = TConfig["table"],
+  TFormat extends Record<string, any> | undefined = ResolveOptionsFormat<TConfig["options"]["format"]>
+> extends Promise<ModelFormatValue<TResult, TFormat>> {
+  with<TValue extends MethodWithValue<TSchema, TTable["relations"]>, TExcludeKeys extends string = TExcludedKeys | "with">(
+    value: TValue,
+  ): ModelQueryResult<
+    MethodWithResult<TValue, TResult, TSchema, TTable>,
+    TConfig,
+    TExcludeKeys
+  >,
+
+  select<TValue extends MethodSelectValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "select">(
+    value: TValue,
+  ): ModelQueryResult<
+    MethodSelectResult<TValue, TResult>,
+    TConfig,
+    TExcludeKeys
+  >,
+
+  exclude<TValue extends MethodExcludeValue<TResult>, TExcludeKeys extends string = TExcludedKeys | "exclude">(
+    value: TValue,
+  ): ModelQueryResult<
+    MethodExcludeResult<TValue, TResult>,
+    TConfig,
+    TExcludeKeys
+  >,
+
+  raw<TExcludeKeys extends string = TExcludedKeys | "raw">(): ModelQueryResult<TResult, TConfig, TExcludeKeys, TSchema, TTable, undefined>;
+
+  debug(): any;
+}
+
+export interface ModelMutateResult<
+  TBaseResult extends Record<string, any> | void,
+  TConfig extends ModelConfig,
+  TResultType extends string = "one"
+> extends Promise<TBaseResult> {
+  // TODO: Planned for future
+  // with<TValue extends MethodWithInsertValue<TSchema, TTable["relations"]>>(
+  //   value: TValue,
+  // ): void;
+
+  return<
+    TValue extends MethodSelectValue<TableOutput<TConfig["table"]>> | undefined,
+    TReturnResult extends MethodReturnResult<TResultType, TConfig> = MethodReturnResult<TResultType, TConfig>,
+    TResult extends Record<string, any> = TValue extends undefined ? TReturnResult : MethodSelectResult<Exclude<TValue, undefined>, TReturnResult>,
+  >(
+    value?: TConfig["dialect"] extends ReturningIdDialects
+      ? never
+      : TValue,
+  ): Omit<
+    ModelMutateResult<
+      TResult,
+      TConfig,
+      TResultType
+    >,
+    "with"
+  >;
+}

package/src/model/shape.ts

@@ -0,0 +1,8 @@
+import type { ModelConfig } from "./config.ts";
+import type { ModelBase, ModelIdentifier } from "./model.ts";
+import type { ResolveOptionsMethods } from "./options.ts";
+
+export type ModelShape<TConfig extends ModelConfig> =
+  ModelIdentifier<TConfig["table"]["name"]> &
+  ModelBase<TConfig> &
+  ResolveOptionsMethods<TConfig["options"]["methods"]>;

package/src/model/table.ts

@@ -0,0 +1,127 @@
+import type { InferInsertModel, InferSelectModel, Table } from "drizzle-orm";
+import type { SchemaEntry, TableRelationalConfig } from "drizzle-orm/relations";
+
+/**
+ * Extracts the column definitions from a Drizzle table configuration.
+ *
+ * This utility resolves the actual Drizzle table type and maps it
+ * to its available column metadata.
+ *
+ * @typeParam TTable - Relational configuration for the table
+ */
+/**
+ * Returns the column map from the underlying Drizzle table definition.
+ *
+ * @typeParam TTable - Relational configuration for the table
+ */
+export type TableColumns<TTable extends TableRelationalConfig> = IsTable<TTable["table"]>["_"]["columns"];
+
+/**
+ * Resolves a single column definition from a table by column name.
+ *
+ * @typeParam TColumnName - Name of the column to extract
+ * @typeParam TTable - Relational configuration for the table
+ */
+/**
+ * Selects a single column definition by name.
+ *
+ * @typeParam TColumnName - Name of the column to extract
+ * @typeParam TTable - Relational configuration for the table
+ */
+export type TableColumn<
+  TColumnName extends string,
+  TTable extends TableRelationalConfig,
+> = TableColumns<TTable>[TColumnName];
+
+/**
+ * Resolves the inferred select model for a table-like input.
+ *
+ * @typeParam TTable - Relation config, schema entry, or table
+ */
+export type TableOutput<TTable extends TableRelationalConfig | SchemaEntry | Table> =
+  NormalizeTable<TTable> extends Table ? InferSelectModel<NormalizeTable<TTable>> : never;
+// Is relation?
+// (TTable extends TableRelationalConfig
+//   ? InferSelectModel<IsTable<TTable["table"]>>
+//   : (TTable extends SchemaEntry
+//     // Is schema entry (view/table)?
+//     ? InferSelectModel<IsTable<TTable>>
+//     : (TTable extends Table
+//       // Is Table?
+//       ? InferSelectModel<TTable>
+//       : never)));
+
+/**
+ * Normalizes relation config and schema entries into a Drizzle table type.
+ *
+ * @typeParam TTable - Relation config, schema entry, or table
+ */
+export type NormalizeTable<TTable extends TableRelationalConfig | SchemaEntry | Table> =
+  // Is relation?
+  (TTable extends TableRelationalConfig
+    ? IsTable<TTable["table"]>
+    : (TTable extends SchemaEntry
+      // Is schema entry (view/table)?
+      ? IsTable<TTable>
+      : (TTable extends Table
+        // Is Table?
+        ? TTable
+        : never)));
+
+/**
+ * Collects target table names from all relations.
+ *
+ * @typeParam TTable - Relational configuration for the table
+ */
+export type TableRelationsTableName<
+  TTable extends TableRelationalConfig
+> = {
+  [K in keyof TTable["relations"]]:
+  TTable["relations"][K]["targetTableName"]
+}[keyof TTable["relations"]];
+
+/**
+ * Maps non-"many" relations to their target table names.
+ *
+ * @typeParam TTable - Relational configuration for the table
+ */
+type TableOneRelationsMap<TTable extends TableRelationalConfig> = {
+  [K in keyof TTable["relations"]as
+  TTable["relations"][K]["relationType"] extends "many"
+  ? never
+  : K
+  ]: TTable["relations"][K]["targetTableName"]
+};
+
+/**
+ * Collects target table names for non-"many" relations.
+ *
+ * @typeParam TTable - Relational configuration for the table
+ */
+export type TableOneRelationsTableName<
+  TTable extends TableRelationalConfig
+> = TableOneRelationsMap<TTable>[keyof TableOneRelationsMap<TTable>];
+
+/**
+ * Narrows a type to a Drizzle table when possible.
+ *
+ * @typeParam T - Candidate table type
+ */
+export type IsTable<T> = T extends Table ? T : never;
+
+/**
+ * Infers insert model for a Drizzle table.
+ *
+ * @typeParam TTable - Drizzle table type
+ */
+export type TableInsertModel<TTable extends Table> =
+  InferInsertModel<TTable>;
+
+/**
+ * Accepts a single insert payload or a batch of insert payloads.
+ *
+ * @typeParam TTable - Drizzle table type
+ */
+export type TableInsertValues<TTable extends Table> =
+  | InferInsertModel<TTable>
+  | InferInsertModel<TTable>[];

package/src/types.ts

@@ -0,0 +1,16 @@
+export type Compose<T, U> = T & U;
+export type Fallback<A, B> = A extends undefined ? B : A;
+export type Replace<T, R> = Omit<T, keyof R> & R;
+export type UnwrapArray<T> = T extends (infer R)[] ? R : T;
+
+export type AddToValues<T extends Record<PropertyKey, any>, A> = {
+  [K in keyof T]: T[K] & A
+};
+
+export type AddUnionToValues<T extends Record<PropertyKey, any>, A> = {
+  [K in keyof T]: T[K] | A
+};
+
+export interface RecursiveBooleanRecord {
+  [key: string]: boolean | RecursiveBooleanRecord;
+}

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

@@ -0,0 +1,40 @@
+import { mysqlDb } from "./db";
+import { modelBuilder } from "src/model";
+import { boolean, int, text, mysqlTable, varchar } from 'drizzle-orm/mysql-core';
+import { defineRelations } from "drizzle-orm";
+import { esc } from "@/model/query/operations";
+
+const usersTable = mysqlTable('users', {
+  id: int('id').primaryKey(),
+  name: text('name').notNull(),
+  verified: boolean('verified').notNull().default(false),
+});
+
+const usersTableDefFn = mysqlTable('users_default_fn', {
+  customId: varchar('id', { length: 256 }).primaryKey().$defaultFn(() => "123"),
+  name: text('name').notNull(),
+});
+
+const schema = {
+  usersTable,
+  usersTableDefFn
+};
+
+const relations = defineRelations(schema, (r) => ({
+  usersTable: {}
+}));
+
+const model = modelBuilder({
+  schema,
+  db: mysqlDb,
+  relations,
+  dialect: "MySQL"
+});
+
+const userModel = model("usersTableDefFn", {});
+
+const testRaw1 = await userModel.where({
+  customId: esc("123")
+}).delete().return();
+
+// testRaw1[0].