@apisr/drizzle-model 0.0.1

package/src/model/core/runtime.ts

@@ -0,0 +1,249 @@
+import type { ModelDialect } from "../dialect.ts";
+import type { ModelOptions } from "../options.ts";
+import type { MethodUpsertValue } from "../methods/upsert.ts";
+import type { MethodWhereValue } from "../methods/query/where.ts";
+import type { MethodWithValue } from "../methods/with.ts";
+
+import { and } from "drizzle-orm";
+import { MutateResult, QueryResult } from "./thenable.ts";
+import type { MutateState, QueryState } from "./thenable.ts";
+import { applyExclude, applyFormat, applySelect } from "./transform.ts";
+import { buildSelectProjection } from "./projection.ts";
+import { compileWhere } from "./where.ts";
+import { runWithJoins } from "./with.ts";
+import type { ReturningIdDialects } from "../dialect.ts";
+
+type AnyObj = Record<string, any>;
+
+type MutateKind = "insert" | "update" | "delete" | "upsert";
+
+type BaseState = {
+  db: any;
+  where: unknown;
+};
+
+// TODO: can be broken...
+function compileEffectiveWhere(table: AnyObj, optionsWhere: unknown, stateWhere: unknown) {
+  const base = compileWhere(table, optionsWhere);
+  const extra = compileWhere(table, stateWhere);
+  if (base && extra) return and(base as any, extra as any);
+  return (base ?? extra) as any;
+}
+
+function isReturningIdDialect(dialect: string): dialect is ReturningIdDialects {
+  return dialect === "MySQL" || dialect === "SingleStore" || dialect === "CockroachDB";
+}
+
+async function execReturn(q: any, mState: MutateState, dialect: string): Promise<any> {
+  if (typeof q?.returning === "function") {
+    return await (mState.returnSelect ? q.returning(mState.returnSelect) : q.returning());
+  }
+  if (isReturningIdDialect(dialect) && typeof q?.$returningId === "function") {
+    return await q.$returningId();
+  }
+  return await q;
+}
+
+function normalizeUpsertTarget(table: AnyObj, target: any): any {
+  if (!target) return target;
+  if (typeof target === "string") return (table as any)[target] ?? target;
+  if (Array.isArray(target)) {
+    return target.map((t) => (typeof t === "string" ? ((table as any)[t] ?? t) : t));
+  }
+  return target;
+}
+
+export function makeModelRuntime(config: {
+  db: any;
+  schema: Record<string, any>;
+  relations: Record<string, any>;
+  tableName: string;
+  dialect: ModelDialect;
+  options: ModelOptions<any, any, any, any>;
+}): any {
+  const baseState: BaseState = {
+    db: config.db,
+    where: undefined as unknown,
+  };
+
+  const build = (state: BaseState): any => {
+    const modelObj: AnyObj = {
+      $model: "model",
+      $modelName: config.tableName,
+      $format: config.options.format,
+      $formatValue: undefined,
+      where(value: MethodWhereValue<any, any>) {
+        return build({ ...state, where: value });
+      },
+      include(value: MethodWithValue<any, any>) {
+        return value;
+      },
+      extend(nextOptions: any) {
+        return makeModelRuntime({
+          ...config,
+          options: {
+            ...config.options,
+            ...nextOptions,
+            methods: {
+              ...(nextOptions?.methods ?? {}),
+              ...(config.options?.methods ?? {}),
+            },
+            format: nextOptions?.format ?? config.options?.format,
+          },
+        });
+      },
+      db(db: any) {
+        return makeModelRuntime({ ...config, db });
+      },
+    };
+
+    const attachMethods = (methods: AnyObj | undefined) => {
+      if (!methods) return;
+      for (const [key, fn] of Object.entries(methods)) {
+        if (typeof fn === "function") {
+          (modelObj as any)[key] = fn.bind(modelObj);
+        }
+      }
+    };
+
+    attachMethods(config.options.methods);
+
+    modelObj.findMany = () => {
+      const runner = async (qState: QueryState) => {
+        const table = (config.schema as any)[config.tableName];
+        const whereSql = compileEffectiveWhere(table as AnyObj, config.options.where, state.where);
+
+        let result: any;
+        if (qState.with) {
+          result = await runWithJoins({
+            db: config.db,
+            schema: config.schema,
+            relations: config.relations,
+            tableName: config.tableName,
+            table,
+            dialect: config.dialect,
+            whereSql,
+            qState,
+            kind: "many",
+          });
+        } else {
+          const { selectMap } = buildSelectProjection(table as AnyObj, qState.select as any, qState.exclude as any);
+          let q = (config.db as any).select(selectMap).from(table);
+          if (whereSql) q = q.where(whereSql);
+          result = await q;
+        }
+
+        let out: any = result;
+        if (qState.select) out = applySelect(out, qState.select);
+        if (qState.exclude) out = applyExclude(out, qState.exclude);
+        if (!qState.raw) out = applyFormat(out, config.options.format);
+        return out;
+      };
+
+      return new QueryResult({} as QueryState, runner) as any;
+    };
+
+    modelObj.findFirst = () => {
+      const runner = async (qState: QueryState) => {
+        const table = (config.schema as any)[config.tableName];
+        const whereSql = compileEffectiveWhere(table as AnyObj, config.options.where, state.where);
+
+        let result: any;
+        if (qState.with) {
+          result = await runWithJoins({
+            db: config.db,
+            schema: config.schema,
+            relations: config.relations,
+            tableName: config.tableName,
+            table,
+            dialect: config.dialect,
+            whereSql,
+            qState,
+            kind: "one",
+          });
+        } else {
+          const { selectMap } = buildSelectProjection(table as AnyObj, qState.select as any, qState.exclude as any);
+          let q = (config.db as any).select(selectMap).from(table);
+          if (whereSql) q = q.where(whereSql);
+          q = q.limit(1);
+          const rows = await q;
+          result = rows[0];
+        }
+
+        let out: any = result;
+        if (qState.select) out = applySelect(out, qState.select);
+        if (qState.exclude) out = applyExclude(out, qState.exclude);
+        if (!qState.raw) out = applyFormat(out, config.options.format);
+        return out;
+      };
+
+      return new QueryResult({} as QueryState, runner) as any;
+    };
+
+    modelObj.insert = (value: any) => {
+      const runner = async (mState: MutateState) => {
+        const table = (config.schema as any)[config.tableName];
+        const q = (config.db as any).insert(table).values(mState.value);
+        return await execReturn(q, mState, config.dialect);
+      };
+
+      return new MutateResult({ kind: "insert" as MutateKind, value } as MutateState, runner) as any;
+    };
+
+    modelObj.update = (value: any) => {
+      const runner = async (mState: MutateState) => {
+        const table = (config.schema as any)[config.tableName];
+        const whereSql = compileEffectiveWhere(table as AnyObj, config.options.where, state.where);
+        let q = (config.db as any).update(table).set(mState.value);
+        if (whereSql) q = q.where(whereSql);
+        return await execReturn(q, mState, config.dialect);
+      };
+
+      return new MutateResult({ kind: "update" as MutateKind, value } as MutateState, runner) as any;
+    };
+
+    modelObj.delete = () => {
+      const runner = async (mState: MutateState) => {
+        const table = (config.schema as any)[config.tableName];
+        const whereSql = compileEffectiveWhere(table as AnyObj, config.options.where, state.where);
+        let q = (config.db as any).delete(table);
+        if (whereSql) q = q.where(whereSql);
+        return await execReturn(q, mState, config.dialect);
+      };
+
+      return new MutateResult({ kind: "delete" as MutateKind } as MutateState, runner) as any;
+    };
+
+    modelObj.upsert = (value: MethodUpsertValue<any>) => {
+      const runner = async (mState: MutateState) => {
+        const table = (config.schema as any)[config.tableName];
+        const insertValues = (mState.value as any).insert;
+        const updateCfg = (mState.value as any).update;
+        const target = normalizeUpsertTarget(table as AnyObj, (mState.value as any).target);
+        let updateSet = updateCfg;
+        if (typeof updateCfg === "function") {
+          updateSet = updateCfg({
+            excluded: (field: string) => (table as any)[field],
+            inserted: (field: string) => (table as any)[field],
+          });
+        }
+
+        let q = (config.db as any).insert(table).values(insertValues);
+        if (q.onConflictDoUpdate) {
+          q = q.onConflictDoUpdate({
+            target,
+            set: updateSet,
+          });
+        }
+
+        return await execReturn(q, mState, config.dialect);
+      };
+
+      return new MutateResult({ kind: "upsert" as MutateKind, value } as MutateState, runner) as any;
+    };
+
+    return modelObj;
+  };
+
+  return build(baseState);
+}

package/src/model/core/thenable.ts

@@ -0,0 +1,85 @@
+import type { MethodExcludeValue } from "../methods/exclude.ts";
+import type { MethodSelectValue } from "../methods/select.ts";
+import type { MethodWithValue } from "../methods/with.ts";
+
+type AnyObj = Record<string, any>;
+
+type QueryState = {
+  where?: unknown;
+  with?: unknown;
+  raw?: boolean;
+  select?: AnyObj;
+  exclude?: AnyObj;
+};
+
+type MutateKind = "insert" | "update" | "delete" | "upsert";
+
+type MutateState = {
+  kind: MutateKind;
+  where?: unknown;
+  value?: unknown;
+  returnSelect?: AnyObj;
+};
+
+export class ThenableResult<T> implements PromiseLike<T> {
+  protected _execute: () => Promise<T>;
+
+  constructor(execute: () => Promise<T>) {
+    this._execute = execute;
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2> {
+    return this._execute().then(onfulfilled as any, onrejected as any);
+  }
+}
+
+export class QueryResult<T> extends ThenableResult<T> {
+  private state: QueryState;
+  private runner: (state: QueryState) => Promise<T>;
+
+  constructor(state: QueryState, runner: (state: QueryState) => Promise<T>) {
+    super(() => runner(state));
+    this.state = state;
+    this.runner = runner;
+  }
+
+  with(value: MethodWithValue<any, any>): any {
+    return new QueryResult({ ...this.state, with: value }, this.runner) as any;
+  }
+
+  select(value: MethodSelectValue<any>): any {
+    return new QueryResult({ ...this.state, select: value as any }, this.runner) as any;
+  }
+
+  exclude(value: MethodExcludeValue<any>): any {
+    return new QueryResult({ ...this.state, exclude: value as any }, this.runner) as any;
+  }
+
+  raw(): any {
+    return new QueryResult({ ...this.state, raw: true }, this.runner) as any;
+  }
+
+  debug(): any {
+    return this.state;
+  }
+}
+
+export class MutateResult<T> extends ThenableResult<T> {
+  private state: MutateState;
+  private runner: (state: MutateState) => Promise<T>;
+
+  constructor(state: MutateState, runner: (state: MutateState) => Promise<T>) {
+    super(() => runner(state));
+    this.state = state;
+    this.runner = runner;
+  }
+
+  return(value?: AnyObj): any {
+    return new MutateResult({ ...this.state, returnSelect: value }, this.runner) as any;
+  }
+}
+
+export type { QueryState, MutateState, MutateKind };

package/src/model/core/transform.ts

@@ -0,0 +1,45 @@
+type AnyObj = Record<string, any>;
+
+export function applySelect(value: any, select: AnyObj): any {
+  if (value == null) return value;
+  if (Array.isArray(value)) return value.map((v) => applySelect(v, select));
+  if (typeof value !== "object") return value;
+
+  const out: AnyObj = {};
+  for (const [key, sel] of Object.entries(select)) {
+    if (sel === true) {
+      out[key] = (value as any)[key];
+      continue;
+    }
+    if (sel && typeof sel === "object") {
+      out[key] = applySelect((value as any)[key], sel as AnyObj);
+    }
+  }
+  return out;
+}
+
+export function applyExclude(value: any, exclude: AnyObj): any {
+  if (value == null) return value;
+  if (Array.isArray(value)) return value.map((v) => applyExclude(v, exclude));
+  if (typeof value !== "object") return value;
+
+  const out: AnyObj = { ...(value as AnyObj) };
+  for (const [key, ex] of Object.entries(exclude)) {
+    if (ex === true) {
+      delete out[key];
+      continue;
+    }
+    if (ex && typeof ex === "object" && key in out) {
+      out[key] = applyExclude(out[key], ex as AnyObj);
+    }
+  }
+  return out;
+}
+
+export function applyFormat(value: any, format: any): any {
+  if (!format) return value;
+  if (value == null) return value;
+  if (Array.isArray(value)) return value.map((v) => applyFormat(v, format));
+  if (typeof value !== "object") return value;
+  return format(value);
+}

package/src/model/core/where.ts

@@ -0,0 +1,183 @@
+import {
+  and,
+  between,
+  eq,
+  gt,
+  gte,
+  ilike,
+  inArray,
+  isNull,
+  like,
+  lt,
+  lte,
+  ne,
+  notBetween,
+  notInArray,
+  or,
+} from "drizzle-orm";
+import type { SQL } from "drizzle-orm";
+import type { EscapedValue } from "../query/operations.ts";
+
+type AnyObj = Record<string, any>;
+
+function isPromiseLike(value: any): value is PromiseLike<any> {
+  return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+
+function isEscapedValue(value: any): value is EscapedValue<any> {
+  return value && typeof value === "object" && ("equal" in value || value.__kind === "esc-op");
+}
+
+function unwrapEscapedValue(column: any, value: any): { sql?: SQL; value?: any } {
+  if (!isEscapedValue(value)) return { value };
+
+  if ((value as any).__kind === "esc-op") {
+    return {
+      sql: (value as any).op(column, (value as any).value),
+    };
+  }
+
+  return {
+    value: (value as any).equal,
+  };
+}
+
+function compileColumnValue(column: any, value: any): SQL | undefined {
+  if (isEscapedValue(value)) {
+    if ((value as any).__kind === "esc-op") {
+      return (value as any).op(column, (value as any).value);
+    }
+    return eq(column, (value as any).equal);
+  }
+
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const parts: SQL[] = [];
+
+    const pushIf = (sql: SQL | undefined) => {
+      if (sql) parts.push(sql);
+    };
+
+    const v: AnyObj = value;
+    if ("eq" in v) {
+      const u = unwrapEscapedValue(column, v.eq);
+      pushIf(u.sql ?? eq(column, u.value));
+    }
+    if ("equal" in v) {
+      const u = unwrapEscapedValue(column, v.equal);
+      pushIf(u.sql ?? eq(column, u.value));
+    }
+    if ("not" in v) {
+      const u = unwrapEscapedValue(column, v.not);
+      pushIf(u.sql ?? ne(column, u.value));
+    }
+    if ("in" in v) {
+      const arr = (v.in ?? []).map((item: any) => unwrapEscapedValue(column, item));
+      const sqls = arr.map((x: { sql?: SQL; value?: any }) => x.sql).filter(Boolean) as SQL[];
+      const values = arr.map((x: { sql?: SQL; value?: any }) => x.value).filter((x: any) => x !== undefined);
+      if (sqls.length) pushIf(or(...sqls));
+      if (values.length) pushIf(inArray(column, values));
+    }
+    if ("nin" in v) {
+      const arr = (v.nin ?? []).map((item: any) => unwrapEscapedValue(column, item));
+      const sqls = arr.map((x: { sql?: SQL; value?: any }) => x.sql).filter(Boolean) as SQL[];
+      const values = arr.map((x: { sql?: SQL; value?: any }) => x.value).filter((x: any) => x !== undefined);
+      if (sqls.length) pushIf(or(...sqls));
+      if (values.length) pushIf(notInArray(column, values));
+    }
+    if ("isNull" in v) pushIf(v.isNull ? isNull(column) : undefined);
+
+    if ("gt" in v) {
+      const u = unwrapEscapedValue(column, v.gt);
+      pushIf(u.sql ?? gt(column, u.value));
+    }
+    if ("gte" in v) {
+      const u = unwrapEscapedValue(column, v.gte);
+      pushIf(u.sql ?? gte(column, u.value));
+    }
+    if ("lt" in v) {
+      const u = unwrapEscapedValue(column, v.lt);
+      pushIf(u.sql ?? lt(column, u.value));
+    }
+    if ("lte" in v) {
+      const u = unwrapEscapedValue(column, v.lte);
+      pushIf(u.sql ?? lte(column, u.value));
+    }
+    if ("between" in v) {
+      const a = unwrapEscapedValue(column, v.between?.[0]);
+      const b = unwrapEscapedValue(column, v.between?.[1]);
+      if (a.sql) pushIf(a.sql);
+      if (b.sql) pushIf(b.sql);
+      pushIf(between(column, a.value, b.value));
+    }
+    if ("notBetween" in v) {
+      const a = unwrapEscapedValue(column, v.notBetween?.[0]);
+      const b = unwrapEscapedValue(column, v.notBetween?.[1]);
+      if (a.sql) pushIf(a.sql);
+      if (b.sql) pushIf(b.sql);
+      pushIf(notBetween(column, a.value, b.value));
+    }
+
+    if ("like" in v) {
+      const u = unwrapEscapedValue(column, v.like);
+      pushIf(u.sql ?? like(column, u.value));
+    }
+    if ("ilike" in v) {
+      const u = unwrapEscapedValue(column, v.ilike);
+      pushIf(u.sql ?? ilike(column, u.value));
+    }
+
+    if (Array.isArray(v.or)) {
+      const sub = v.or
+        .map((item: any) => compileColumnValue(column, item))
+        .filter(Boolean) as SQL[];
+      if (sub.length) pushIf(or(...sub));
+    }
+
+    if (Array.isArray(v.and)) {
+      const sub = v.and
+        .map((item: any) => compileColumnValue(column, item))
+        .filter(Boolean) as SQL[];
+      if (sub.length) pushIf(and(...sub));
+    }
+
+    if (!parts.length) return undefined;
+    return parts.length === 1 ? parts[0] : and(...parts);
+  }
+
+  return eq(column, value);
+}
+
+export function compileWhereObject(fields: AnyObj, where: AnyObj): SQL | undefined {
+  const parts: SQL[] = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (value === undefined) continue;
+
+    const col = (fields as any)[key];
+    if (col) {
+      const sql = compileColumnValue(col, value);
+      if (sql) parts.push(sql);
+      continue;
+    }
+
+    if (value && typeof value === "object") {
+      throw new Error(`Relation where is not implemented yet for key '${key}'.`);
+    }
+  }
+
+  if (!parts.length) return undefined;
+  return parts.length === 1 ? parts[0] : and(...parts);
+}
+
+export function compileWhere(fields: AnyObj, where: unknown): SQL | undefined {
+  if (!where) return undefined;
+
+  if (typeof where === "object" && where && !isPromiseLike(where)) {
+    if ((where as any).$model === "model") {
+      throw new Error("Model-as-where is not implemented yet.");
+    }
+    if ((where as any).getSQL) return where as any;
+    return compileWhereObject(fields, where as AnyObj);
+  }
+
+  return where as any;
+}

package/src/model/core/with.ts

@@ -0,0 +1,28 @@
+import type { QueryState } from "./thenable.ts";
+import { executeWithJoins } from "./joins.ts";
+
+type AnyObj = Record<string, any>;
+
+export async function runWithJoins(args: {
+  db: any;
+  schema: Record<string, any>;
+  relations: Record<string, any>;
+  tableName: string;
+  table: AnyObj;
+  dialect: string;
+  whereSql?: any;
+  qState: QueryState;
+  kind: "many" | "one";
+}): Promise<any> {
+  return await executeWithJoins({
+    db: args.db,
+    schema: args.schema,
+    relations: args.relations,
+    baseTableName: args.tableName,
+    baseTable: args.table,
+    dialect: args.dialect,
+    whereSql: args.whereSql,
+    withValue: args.qState.with as any,
+    limitOne: args.kind === "one",
+  });
+}

package/src/model/dialect.ts

@@ -0,0 +1,11 @@
+export type ModelDialect = SqlLiteDialect | MySqlDialect | SingleStoreDialect | PgDialect | MssqlDialect | CockroachDbDialect | UnknownDialect;
+
+export type UnknownDialect = "Unknown[DO_NOT_USE]";
+export type SqlLiteDialect = "SQLite";
+export type MySqlDialect = "MySQL";
+export type SingleStoreDialect = "SingleStore";
+export type PgDialect = "PostgreSQL";
+export type MssqlDialect = "MSSQL";
+export type CockroachDbDialect = "CockroachDB";
+
+export type ReturningIdDialects = MySqlDialect | SingleStoreDialect | CockroachDbDialect;

package/src/model/foreigns.ts

@@ -0,0 +1,31 @@
+import type {
+  TableRelationalConfig,
+  TablesRelationalConfig,
+} from "drizzle-orm/relations";
+import type { ModelDialect } from "./dialect.ts";
+import type { Model, ModelIdentifier } from "./model.ts";
+import type { ModelLevelMethods } from "./methods/levels.ts";
+
+// export type ModelForeignContext<TSchema extends TablesRelationalConfig, TTableName extends string, TDialect extends ModelDialect, ExcludedKeys extends string = string> = Omit<Model<TSchema, TSchema[TTableName], TDialect>, ModelLevelMethods | ExcludedKeys>;
+// export type ModelForeignField<TSchema extends TablesRelationalConfig, TTableName extends string, TDialect extends ModelDialect, ExcludedKeys extends string = string> = <TContext extends ModelForeignContext<TSchema, TTableName, TDialect, ExcludedKeys>>(c: TContext) => TContext | any;
+
+// export type ModelForegins<
+//   TSchema extends TablesRelationalConfig,
+//   TTable extends TableRelationalConfig,
+//   TDialect extends ModelDialect,
+// > = {
+//     [K in keyof TTable["relations"]]: <TName extends string = TTable["relations"][K & string]["targetTableName"], TValue = (ModelForeignField<TSchema, TName, TDialect, K & string>) | ModelIdentifier<TName>>(
+//       fn: TValue extends Function
+//         ? TValue
+//         : (TValue extends ModelIdentifier<TName> ? TValue
+//           : never)
+//     ) => Omit<Model<TSchema, TTable, TDialect>, K>;
+//   };
+
+export type ModelForegins<
+  TSchema extends TablesRelationalConfig,
+  TTable extends TableRelationalConfig,
+  TDialect extends ModelDialect,
+> = {
+
+  };

package/src/model/format.ts

@@ -0,0 +1,19 @@
+export type ModelFormatValue<
+  TValue extends Record<string, any>,
+  TFormat extends Record<string, any> | undefined
+> = TFormat extends undefined
+  ? TValue
+  : TValue extends (infer TItem)[]
+    ? (TItem extends Record<string, any>
+        ? ModelFormatValue<TItem, TFormat>[]
+        : TValue)
+    : Omit<TValue, keyof TFormat> & TFormat;
+
+// export type ModelFormatResult<
+//   TResult extends Promise<any>,
+//   TFormat extends Record<string, any> | undefined
+// > = TFormat extends undefined ? TResult : (TResult extends Promise<infer T>
+//   ? (T extends Record<string, any>
+//     ? ModelFormatValue<T, Exclude<TFormat, undefined>>
+//     : never)
+//   : never);

package/src/model/index.ts

@@ -0,0 +1 @@
+export * from "./builder.ts";

package/src/model/methods/exclude.ts

@@ -0,0 +1,32 @@
+import type { MethodSelectValue } from "./select.ts";
+
+export type ResolveMethodExcludeValue<
+	TValue extends Record<string, any>,
+	TResult extends Record<string, any>,
+> = {
+	[Key in keyof TResult as TValue[Key & string] extends true
+		? never
+		: Key]: TValue[Key & string] extends object
+		? TResult[Key & string] extends (infer RItem)[]
+			? RItem extends Record<string, any>
+				? ResolveMethodExcludeValue<TValue[Key & string], RItem>[]
+				: never
+			: TResult[Key & string] extends Record<string, any>
+				? ResolveMethodExcludeValue<TValue[Key & string], TResult[Key & string]>
+				: never
+		: TResult[Key & string];
+};
+
+export type MethodExcludeResult<
+	TValue extends Record<string, any>,
+	TResult extends Record<string, any>,
+> = TResult extends any[]
+	? TResult extends (infer RItem)[]
+		? RItem extends Record<string, any>
+			? ResolveMethodExcludeValue<TValue, RItem>[]
+			: ResolveMethodExcludeValue<TValue, TResult>[]
+		: ResolveMethodExcludeValue<TValue, TResult>
+	: ResolveMethodExcludeValue<TValue, TResult>;
+
+export type MethodExcludeValue<TResult extends Record<string, any>> =
+	MethodSelectValue<TResult>;

package/src/model/methods/include.ts

@@ -0,0 +1,3 @@
+export type MethodIncludeIdentifier<T> = {
+  $include: T;
+};