prisma-ts-select 0.0.34 → 0.1.2

package/dist/extend/extend.cjs

@@ -1,357 +0,0 @@
-'use strict';
-
-var extension = require('@prisma/client/extension');
-var tsPattern = require('ts-pattern');
-
-const DB = {};
-class DbSelect {
-  constructor(db) {
-    this.db = db;
-  }
-  from(baseTable, alias) {
-    return new _fJoin(this.db, {
-      tables: [{
-        table: baseTable,
-        alias
-      }],
-      selects: []
-    });
-  }
-}
-class _fRun {
-  constructor(db, values) {
-    this.db = db;
-    this.values = values;
-    this.values.limit = typeof this.values.limit === "number" ? this.values.limit : void 0;
-    this.values.offset = typeof this.values.offset === "number" ? this.values.offset : void 0;
-  }
-  run() {
-    return this.db.$queryRawUnsafe(
-      this.getSQL()
-    );
-  }
-  getTables() {
-    return {};
-  }
-  getFields() {
-    return {};
-  }
-  getResultType() {
-    return {};
-  }
-  getSQL(formatted = false) {
-    function processCondition(condition, formatted2) {
-      return "(" + Object.keys(condition).map((field) => {
-        const value = condition[field];
-        if (typeof value === "object" && value !== null && !Array.isArray(value) && "op" in value) {
-          switch (value.op) {
-            case "IN":
-            case "NOT IN":
-              const valuesList = value.values.map((v) => typeof v === "string" ? `'${v}'` : v).join(", ");
-              return `${String(field)} ${value.op} (${valuesList})`;
-            case "BETWEEN":
-              if (value.values.length > 2) throw new Error("Too many items supplied to op BETWEEN");
-              const [start, end] = value.values;
-              return `${String(field)} BETWEEN ${typeof start === "string" ? `'${start}'` : start} AND ${typeof end === "string" ? `'${end}'` : end}`;
-            case "LIKE":
-            case "NOT LIKE":
-              return `${String(field)} ${value.op} '${value.value}'`;
-            case "IS NULL":
-            case "IS NOT NULL":
-              return `${String(field)} ${value.op}`;
-            case ">":
-            case ">=":
-            case "<":
-            case "<=":
-            case "!=":
-              return `${String(field)} ${value.op} ${typeof value.value === "string" ? `'${value.value}'` : value.value}`;
-            default:
-              throw new Error(`Unsupported operation: ${value.op}`);
-          }
-        } else if (Array.isArray(value)) {
-          const valuesList = value.map((v) => typeof v === "string" ? `'${v}'` : v).join(", ");
-          return `${String(field)} IN (${valuesList})`;
-        } else if (value === null) {
-          return `${String(field)} IS NULL`;
-        } else {
-          return `${String(field)} = ${typeof value === "string" ? `'${value}'` : value}`;
-        }
-      }).join(" AND " + (" ")) + " )";
-    }
-    function processCriteria(main, joinType = "AND", formatted2 = false) {
-      const results = [];
-      for (const criteria of main) {
-        if (typeof criteria === "string") {
-          results.push(criteria);
-          continue;
-        }
-        for (const criterion in criteria) {
-          results.push(tsPattern.match(criterion).returnType().with("$AND", (criterion2) => {
-            return "(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "AND", formatted2) + ")";
-          }).with("$OR", (criterion2) => {
-            return "(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "OR", formatted2) + ")";
-          }).with("$NOT", (criterion2) => {
-            return "(NOT(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "AND", formatted2) + "))";
-          }).with("$NOR", (criterion2) => {
-            return "(NOT(" + //@ts-expect-error criterion
-            processCriteria(criteria[criterion2], "OR", formatted2) + "))";
-          }).with(tsPattern.P.string, () => {
-            return processCondition(criteria);
-          }).exhaustive());
-        }
-      }
-      return results.join((formatted2 ? "\n" : " ") + joinType + (formatted2 ? "\n" : " "));
-    }
-    const whereClause = this.values.where !== void 0 ? processCriteria(this.values.where, "AND", formatted) : void 0;
-    const havingClause = this.values.having !== void 0 ? processCriteria(this.values.having, "AND", formatted) : void 0;
-    const [base, ...joins] = this.values.tables;
-    const baseTable = base.alias ? `${base.table} AS \`${base.alias}\`` : base.table;
-    return [
-      this.values.selects.length === 0 ? "" : "SELECT " + (this.values.selectDistinct === true ? "DISTINCT " : "") + this.values.selects.join(", "),
-      `FROM ${baseTable}`,
-      joins.map(({
-        table,
-        local,
-        remote,
-        alias
-      }) => {
-        const tLocal = (alias || table) + "." + local;
-        return `JOIN ${!!alias ? table + " AS `" + alias + "`" : table} ON ${tLocal} = ${remote}`;
-      }).join(formatted ? "\n" : " ") ?? "",
-      !whereClause ? "" : `WHERE ${whereClause}`,
-      !this.values.groupBy?.length ? "" : `GROUP BY ${this.values.groupBy.join(", ")}`,
-      !havingClause ? "" : `HAVING ${havingClause}`,
-      !(this.values.orderBy && this.values.orderBy.length > 0) ? "" : "ORDER BY " + this.values.orderBy.join(", "),
-      !this.values.limit ? "" : `LIMIT ${this.values.limit}`,
-      !this.values.offset ? "" : `OFFSET ${this.values.offset}`
-    ].filter(Boolean).join(formatted ? "\n" : " ").trim() + ";";
-  }
-}
-class _fOffset extends _fRun {
-  offset(offset) {
-    return new _fRun(this.db, { ...this.values, offset });
-  }
-}
-class _fLimit extends _fRun {
-  limit(limit) {
-    return new _fOffset(this.db, { ...this.values, limit });
-  }
-}
-class _fOrderBy extends _fLimit {
-  orderBy(orderBy) {
-    return new _fLimit(this.db, { ...this.values, orderBy });
-  }
-}
-class _fSelect extends _fOrderBy {
-  select(select, alias) {
-    const tableColMatch = select.match(/^(\w+)\.(.*?)$/);
-    if (tableColMatch) {
-      const [, tableName, colName] = tableColMatch;
-      const tableObject = this.values.tables.find((t) => (t.alias || t.table) === tableName);
-      if (!tableObject) throw new Error(`Table "${tableName}" not found in query`);
-      const tableFields = DB[tableObject.table];
-      if (!tableFields) {
-        throw new Error(`Table "${tableName}" not found in database schema`);
-      }
-      if (colName === "*") {
-        const hasMultipleTables = this.values.tables && this.values.tables.length > 1 || false;
-        const expandedSelects = Object.keys(tableFields.fields).map((field) => {
-          if (hasMultipleTables) {
-            return `${tableName}.${field} AS \`${tableName}.${field}\``;
-          }
-          return `${field}`;
-        });
-        return new _fSelect(this.db, {
-          ...this.values,
-          selects: [...this.values.selects, ...expandedSelects]
-        });
-      } else if (!alias && !!colName) {
-        const currentTablesWithFields = this.values.tables.reduce((acc, table) => {
-          const { table: real } = table;
-          for (const col in DB[real].fields) {
-            acc[col] = acc[col] ? acc[col] + 1 : 1;
-          }
-          return acc;
-        }, {});
-        if (!currentTablesWithFields[colName]) {
-          throw new Error(`Column "${colName}" not found in database schema`);
-        }
-        if (currentTablesWithFields[colName] > 1) {
-          return new _fSelect(this.db, {
-            ...this.values,
-            selects: [...this.values.selects, `${select} AS \`${select}\``]
-          });
-        } else {
-          return new _fSelect(this.db, {
-            ...this.values,
-            selects: [...this.values.selects, `${colName}`]
-          });
-        }
-      }
-    }
-    if (alias !== void 0) {
-      return new _fSelect(this.db, {
-        ...this.values,
-        selects: [...this.values.selects, `${select} AS \`${alias}\``]
-      });
-    }
-    return new _fSelect(this.db, {
-      ...this.values,
-      selects: [...this.values.selects, select]
-    });
-  }
-}
-class _fSelectDistinct extends _fSelect {
-  selectDistinct() {
-    return new _fSelect(this.db, { ...this.values, selectDistinct: true });
-  }
-  selectAll() {
-    const selects = function(values) {
-      if (values.tables && values.tables.length > 1) {
-        return [
-          /*values.baseTable,*/
-          ...values.tables.map((t) => t.table)
-        ].reduce((acc, table) => {
-          return acc.concat(Object.keys(DB[table].fields).map((field) => `${table}.${field} AS \`${table}.${field}\``));
-        }, []);
-      }
-      return Object.keys(DB[values.tables[0].table].fields);
-    }(this.values);
-    return new _fOrderBy(this.db, {
-      ...this.values,
-      selects
-    });
-  }
-  //TODO
-  // selectAllOmit() {
-  //     throw new Error("Not implemented yet")
-  // }
-}
-class _fHaving extends _fSelectDistinct {
-  // TODO Allowed Fields
-  //  - specified in groupBy
-  having(criteria) {
-    return new _fSelectDistinct(this.db, {
-      ...this.values,
-      having: [criteria]
-    });
-  }
-}
-class _fGroupBy extends _fHaving {
-  //TODO this should only accept columns for tables in play
-  groupBy(groupBy) {
-    return new _fHaving(this.db, { ...this.values, groupBy });
-  }
-}
-class _fWhere extends _fGroupBy {
-  whereNotNull(col) {
-    return new _fWhere(this.db, {
-      ...this.values,
-      where: [
-        ...this.values.where || [],
-        {
-          $AND: (
-            //@ts-expect-error todo comeback to, col is a string or never
-            [{ [col]: { op: "IS NOT NULL" } }]
-          )
-        }
-      ]
-    });
-  }
-  whereIsNull(col) {
-    return new _fWhere(this.db, {
-      ...this.values,
-      where: [
-        ...this.values.where || [],
-        {
-          $AND: (
-            //@ts-expect-error todo comeback to, col is a string or never
-            [{ [col]: { op: "IS NULL" } }]
-          )
-        }
-      ]
-    });
-  }
-  where(criteria) {
-    return new _fGroupBy(this.db, {
-      ...this.values,
-      where: [...this.values.where || [], criteria]
-    });
-  }
-  whereRaw(where) {
-    return new _fGroupBy(this.db, {
-      ...this.values,
-      where: [...this.values.where || [], where.replace(/^\s*where\s*/i, "").trim()]
-    });
-  }
-}
-class _fJoin extends _fWhere {
-  // Implementation
-  join(tableOrOptions, field, reference) {
-    let table;
-    let local;
-    let remote;
-    let tableAlias;
-    if (typeof tableOrOptions === "object" && "table" in tableOrOptions) {
-      table = tableOrOptions.table.trim();
-      local = tableOrOptions.src;
-      remote = tableOrOptions.on;
-      tableAlias = tableOrOptions.alias?.trim();
-    } else {
-      const parts = tableOrOptions.split(" ");
-      table = parts[0];
-      tableAlias = parts[1]?.trim();
-      local = field;
-      remote = reference;
-    }
-    return new _fJoin(this.db, {
-      ...this.values,
-      tables: [...this.values.tables || [], {
-        table,
-        local,
-        remote,
-        alias: tableAlias
-      }]
-    });
-  }
-  // Implementation
-  joinUnsafeTypeEnforced(tableOrOptions, field, reference) {
-    return this.join(tableOrOptions, field, reference);
-  }
-  // Implementation
-  joinUnsafeIgnoreType(tableOrOptions, field, reference) {
-    return this.join(tableOrOptions, field, reference);
-  }
-  // innerJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // leftJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // rightJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // fullJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // crossJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-  // outerJoin(table: TTableSources, col1:string, col2:string){
-  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
-  // }
-}
-var extend_default = {
-  client: {
-    $from(table) {
-      const client = extension.Prisma.getExtensionContext(this);
-      const [base, ...aliases] = table.split(" ");
-      return new DbSelect(client).from(base.trim(), aliases.join().trim() || void 0);
-    }
-  }
-};
-
-module.exports = extend_default;

package/dist/extend/extend.d.cts

@@ -1,264 +0,0 @@
-import { Prisma } from '@prisma/client/extension';
-import { PrismaClient } from '@prisma/client';
-
-declare const DB: DBType;
-type TDB = typeof DB;
-type DeepWriteable<T> = {
-    -readonly [P in keyof T]: DeepWriteable<T[P]>;
-};
-type _db = DeepWriteable<TDB>;
-type DATABASE = {
-    [k in keyof _db]: {
-        table: k;
-        fields: {
-            [f in keyof _db[k]["fields"]]: StrTypeToTSType<_db[k]["fields"][f]>;
-        };
-        relations: _db[k]["relations"];
-    };
-}[keyof TDB];
-type JSONPrimitive = string | number | boolean | null;
-type JSONValue = JSONPrimitive | JSONObject | JSONArray;
-type JSONObject = {
-    [member: string]: JSONValue;
-};
-type JSONArray = Array<JSONValue>;
-type StrTypeToTSType<str> = str extends string ? (GetTSType<RemoveNullChar<str>> | IsNullable<str>) : never;
-type GetTSType<str extends string> = str extends `String` ? string : str extends `BigInt` ? bigint : str extends `Int` ? number : str extends `Float` ? number : str extends `Decimal` ? number : str extends `Boolean` ? boolean : str extends `DateTime` ? Date : str extends `Bytes` ? Buffer : str extends `Json` ? JSONValue : "Unknown type";
-type IsNullable<str extends string> = str extends `?${string}` ? null : never;
-type RemoveNullChar<str extends string> = str extends `?${infer s}` ? s : str;
-type DBType = Record<string, {
-    fields: Record<string, string>;
-    relations: Record<string, Record<string, Array<string>>>;
-}>;
-type Filter<a, b> = a extends b ? a : never;
-type IsString<T> = T extends string ? T : never;
-type ValidSelect<Tables extends TArrSources> = "*" | GetOtherColumns<Tables> | GetTableStar<Tables>;
-type GetTableStar<Tables extends TArrSources> = Tables extends [infer T extends TTableSources, ...Array<TTableSources>] ? T extends string ? `${T}.*` | GetTableStarJoined<Tables[number]> : `${T[1]}.*` | GetTableStarJoined<Tables[number]> : never;
-type GetTableStarJoined<T extends TTableSources> = T extends string ? `${T}.*` : `${T[1]}.*`;
-type ExtractColumnType<Column extends string, TSources extends TArrSources, TFields extends TFieldsType> = Column extends `${infer T}.${infer F}` ? T extends keyof TFields ? F extends keyof TFields[T] ? TFields[T][F] : never : never : Column extends keyof TFields[TSources[0] extends string ? TSources[0] : `Come back to 1`] ? TFields[TSources[0] extends string ? TSources[0] : `Come back To 2`][Column] : never;
-type TTables = DATABASE["table"];
-type TTableSources = DATABASE["table"] | [table: DATABASE["table"], alias: string];
-type TArrSources = [TTableSources, ...Array<TTableSources>];
-type ClauseType = Array<string | WhereCriteria<TArrSources, Record<string, any>>>;
-type Values = {
-    selectDistinct?: true;
-    selects: Array<string>;
-    tables: [{
-        table: TTables;
-        alias?: string;
-    }, ...Array<{
-        table: TTables;
-        local: string;
-        remote: string;
-        alias?: string;
-    }>];
-    limit?: number;
-    offset?: number;
-    where?: ClauseType;
-    having?: ClauseType;
-    groupBy?: Array<string>;
-    orderBy?: Array<`${string}${"" | " DESC" | " ASC"}`>;
-};
-declare class _fRun<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> {
-    protected db: PrismaClient;
-    protected values: Values;
-    constructor(db: PrismaClient, values: Values);
-    run(): Prisma.PrismaPromise<Array<TSelectRT>>;
-    getTables(): TSources;
-    getFields(): TFields;
-    getResultType(): Array<TSelectRT>;
-    getSQL(formatted?: boolean): string;
-}
-declare class _fOffset<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fRun<TSources, TFields, TSelectRT> {
-    offset(offset: number): _fRun<TSources, TFields, TSelectRT>;
-}
-declare class _fLimit<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fRun<TSources, TFields, TSelectRT> {
-    limit(limit: number): _fOffset<TSources, TFields, TSelectRT>;
-}
-type OrderBy<Tables extends TArrSources, TSelectRT extends Record<string, any> = {}> = Tables extends [infer T extends TTableSources, ...Array<TTableSources>] ? GetColsBaseTable<T> | GetJoinCols<Tables[number]> | (keyof TSelectRT & string) : never;
-declare class _fOrderBy<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fLimit<TSources, TFields, TSelectRT> {
-    orderBy(orderBy: Array<`${OrderBy<TSources, TSelectRT>}${"" | " DESC" | " ASC"}`>): _fLimit<TSources, TFields, TSelectRT>;
-}
-type MergeItems<Field extends string, TSources extends TArrSources, TFields extends TFieldsType, IncTName extends boolean = false, TLTables extends string = TablesArray2Name<TSources>[number]> = Field extends "*" ? Prettify<IterateTables<TSources, TFields, IncTName>> : Field extends `${infer T}.*` ? T extends keyof TFields ? [TSources] extends [[T]] ? TFields[T] : T extends string ? IterateTablesFromFields<T, TFields[T], true> : never : never : Field extends `${infer T extends TLTables}.${infer F extends string}` ? T extends keyof TFields ? F extends keyof TFields[T] ? IsColumnUnique<F, TSources> extends true ? Prettify<Pick<TFields[T], F>> : Prettify<{
-    [K in Field]: TFields[T][F];
-}> : never : never : FindColumnInFields<Field, TFields>;
-type FindColumnInFields<Column extends string, TFields extends TFieldsType, Tables extends keyof TFields = keyof TFields> = Tables extends keyof TFields ? TFields[Tables] extends Record<Column, any> ? Pick<TFields[Tables], Column> : never : never;
-type IterateTables<Tables extends Array<TTableSources>, TFields extends TFieldsType, IncTName extends boolean, acc extends Record<string, any> = {}> = Tables extends [infer T extends TTableSources, ...infer Rest extends Array<TTableSources>] ? [IncTName] extends [false] ? IterateTables<Rest, TFields, IncTName, acc & TFields[T extends string ? T : T[1]]> : IterateTables<Rest, TFields, IncTName, acc & IterateTablesFromFields<T, TFields[T extends string ? T : T[1]], IncTName>> : acc;
-type GenName<T extends string, F extends unknown, IncName extends boolean> = F extends string ? [IncName] extends [false] ? F : `${T}.${F}` : never;
-type IterateTablesFromFields<Table extends TTableSources, TFields extends Record<string, string>, IncTName extends boolean> = {
-    [f in keyof TFields as GenName<Table extends string ? Table : `Come back to 6`, f, IncTName>]: TFields[f];
-};
-type TablesArray2Name<TSources extends Array<TTableSources>, acc extends Array<string> = []> = TSources extends [infer T extends TTableSources, ...infer Rest extends Array<TTableSources>] ? TablesArray2Name<Rest, [...acc, GetAliasTableNames<T>]> : acc;
-type GetColumnNamesFromTable<TDBBase extends TTableSources> = keyof GetFieldsFromTable<GetRealTableNames<TDBBase>>;
-type GetColumnsFromTables<Tables extends Array<TTableSources>> = Tables extends [infer T extends TTableSources, ...infer Rest extends Array<TTableSources>] ? GetColumnNamesFromTable<T> | GetColumnsFromTables<Rest> : never;
-type GetDuplicateColumnsPairwise<Tables extends TArrSources> = Tables extends [infer T1 extends TTableSources, infer T2 extends TTableSources, ...infer Rest extends Array<TTableSources>] ? (GetColumnNamesFromTable<T1> & GetColumnNamesFromTable<T2>) | GetDuplicateColumnsPairwise<[T1, ...Rest]> | GetDuplicateColumnsPairwise<[T2, ...Rest]> : never;
-type IsColumnUnique<Col extends string, Tables extends TArrSources> = Col extends GetDuplicateColumnsPairwise<Tables> ? false : true;
-type GetOtherColumns<Tables extends TArrSources> = Exclude<GetColumnsFromTables<Tables>, GetDuplicateColumnsPairwise<Tables>> | GetJoinCols<Tables[number]>;
-declare class _fSelect<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fOrderBy<TSources, TFields, TSelectRT> {
-    select<const TSelect extends ValidSelect<TSources>, TAlias extends string = never>(select: TSelect, alias?: TAlias): [TAlias] extends [never] ? _fSelect<TSources, TFields, Prettify<TSelectRT & MergeItems<TSelect, TSources, TFields>>> : _fSelect<TSources, TFields, Prettify<TSelectRT & Record<TAlias, ExtractColumnType<TSelect, TSources, TFields>>>>;
-}
-type CountKeys<T extends Array<TTableSources>, acc extends Array<true> = []> = T extends [string, ...infer R extends Array<string>] ? CountKeys<R, [...acc, true]> : acc["length"];
-declare class _fSelectDistinct<TSources extends TArrSources, TFields extends TFieldsType, TSelectRT extends Record<string, any> = {}> extends _fSelect<TSources, TFields, TSelectRT> {
-    selectDistinct(): _fSelect<TSources, TFields, TSelectRT>;
-    selectAll<TableCount = CountKeys<TSources>>(): _fOrderBy<TSources, TFields, IterateTables<TSources, TFields, TableCount extends 1 ? false : true, {}> extends infer T ? { [K in keyof T]: IterateTables<TSources, TFields, TableCount extends 1 ? false : true, {}>[K]; } : never>;
-}
-declare class _fHaving<TSources extends TArrSources, TFields extends TFieldsType> extends _fSelectDistinct<TSources, TFields> {
-    having<const TCriteria extends WhereCriteria<TSources, TFields>>(criteria: TCriteria): _fSelectDistinct<TSources, TFields, {}>;
-}
-declare class _fGroupBy<TSources extends TArrSources, TFields extends TFieldsType> extends _fHaving<TSources, TFields> {
-    groupBy<TSelect extends GetOtherColumns<TSources>>(groupBy: Array<TSelect>): _fHaving<TSources, TFields>;
-}
-type OptionalRecord<K extends PropertyKey, V> = {
-    [key in K]?: V;
-};
-type OptionalObject<K extends Record<PropertyKey, unknown>> = {
-    [key in keyof K]?: K[key];
-};
-type COND_NUMERIC<key extends PropertyKey, keyType> = OptionalRecord<key, keyType> | OptionalRecord<key, {
-    op: 'IN' | 'NOT IN';
-    values: Array<keyType>;
-}> | OptionalRecord<key, {
-    op: 'BETWEEN';
-    values: [keyType, keyType];
-}> | OptionalRecord<key, {
-    op: '>' | '>=' | '<' | '<=' | '!=';
-    value: keyType;
-}>;
-type COND_STRING<key extends PropertyKey> = OptionalRecord<key, string> | OptionalRecord<key, {
-    op: 'IN' | 'NOT IN';
-    values: Array<string>;
-}> | OptionalRecord<key, {
-    op: 'LIKE' | 'NOT LIKE';
-    value: string;
-}> | OptionalRecord<key, {
-    op: '!=';
-    value: string;
-}>;
-type COND_DATETIME<key extends PropertyKey, keyType> = OptionalRecord<key, keyType> | OptionalRecord<key, {
-    op: 'IN' | 'NOT IN';
-    values: Array<keyType>;
-}> | OptionalRecord<key, {
-    op: 'BETWEEN';
-    values: [keyType, keyType];
-}> | OptionalRecord<key, {
-    op: '>' | '>=' | '<' | '<=' | '!=';
-    value: keyType;
-}>;
-type COND_BOOLEAN<key extends PropertyKey, keyType> = OptionalRecord<key, keyType> | OptionalRecord<key, {
-    op: '!=';
-    value: keyType;
-}>;
-type COND_NULL<key extends PropertyKey, keyType> = keyType extends null ? OptionalRecord<key, {
-    op: 'IS NULL' | 'IS NOT NULL';
-}> : never;
-type SQLCondition<T> = Prettify<{
-    [K in keyof T]?: (Exclude<T[K], null> extends number ? COND_NUMERIC<K, Exclude<T[K], null>> : Exclude<T[K], null> extends bigint ? COND_NUMERIC<K, Exclude<T[K], null>> : Exclude<T[K], null> extends string ? COND_STRING<K> : Exclude<T[K], null> extends boolean ? COND_BOOLEAN<K, Exclude<T[K], null>> : Exclude<T[K], null> extends Date ? COND_DATETIME<K, Exclude<T[K], null>> : "Unsupported Data Type") | COND_NULL<K, T[K]>;
-}[keyof T]>;
-type TableFieldType<Table extends string, Fields extends Record<string, any>> = {
-    [f in keyof Fields as CombineToString<f, Table>]: Fields[f];
-};
-type LogicalOperator = '$AND' | '$OR' | '$NOT' | "$NOR";
-type WhereCriteria<T extends TArrSources, TFields extends TFieldsType, F = WhereCriteria_Fields<T, TFields>> = F & {
-    [k in LogicalOperator]?: [WhereCriteria<T, TFields, F>, ...Array<WhereCriteria<T, TFields, F>>];
-};
-type WhereCriteria_Fields<T extends Array<TTableSources>, TFields extends TFieldsType, acc = {}> = T extends readonly [infer HEAD, ...infer Rest] ? HEAD extends string ? Rest extends Array<TTableSources> ? WhereCriteria_Fields<Rest, TFields, OptionalObject<acc & (TableFieldType<HEAD, TFields[HEAD]> | SQLCondition<TableFieldType<HEAD, TFields[HEAD]>>)>> : WhereCriteria_Fields<[], TFields, OptionalObject<acc & (TableFieldType<HEAD, TFields[HEAD]> | SQLCondition<TableFieldType<HEAD, TFields[HEAD]>>)>> : HEAD extends [infer R_NAME extends string, infer A_NAME extends string] ? Rest extends Array<TTableSources> ? WhereCriteria_Fields<Rest, TFields, OptionalObject<acc & (TableFieldType<A_NAME, TFields[R_NAME]> | SQLCondition<TableFieldType<A_NAME, TFields[R_NAME]>>)>> : WhereCriteria_Fields<[], TFields, OptionalObject<acc & (TableFieldType<A_NAME, TFields[R_NAME]> | SQLCondition<TableFieldType<A_NAME, TFields[R_NAME]>>)>> : never : acc;
-type OnlyNull<T, R> = T extends null ? R : never;
-type FindColsWithNull<TFields extends TFieldsType> = Prettify<{
-    [Table in keyof TFields]: {
-        [Field in keyof TFields[Table]]: OnlyNull<TFields[Table][Field], CombineToString<Field, Table>>;
-    }[keyof TFields[Table]];
-}[keyof TFields]>;
-type NO_START_WITH_WHERE<RAW extends string> = Uppercase<TRIM<RAW>> extends `WHERE ${string}` ? "Please do not start with `WHERE`" : RAW;
-type TRIM<S extends string> = S extends ` ${infer S2}` ? TRIM<S2> : S;
-declare class _fWhere<TSources extends TArrSources, TFields extends TFieldsType> extends _fGroupBy<TSources, TFields> {
-    whereNotNull<const TColWithNull extends FindColsWithNull<TFields>>(col: TColWithNull): _fWhere<TSources, TColWithNull extends `${infer table}.${infer col}` ? Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>>[K_1]; } : never) extends infer T ? { [K in keyof T]: (Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, Exclude<Pick<TFields, table>[table][col], null>>>[K_1]; } : never))[K]; } : never : never>;
-    whereIsNull<const TColWithNull extends FindColsWithNull<TFields>>(col: TColWithNull): _fWhere<TSources, TColWithNull extends `${infer table}.${infer col}` ? Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>>[K_1]; } : never) extends infer T ? { [K in keyof T]: (Omit<TFields, table> & (Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>> extends infer T_1 ? { [K_1 in keyof T_1]: Record<table, Omit<Pick<TFields, table>[table], col> & Record<col, null>>[K_1]; } : never))[K]; } : never : never>;
-    where<const TCriteria extends WhereCriteria<TSources, TFields>>(criteria: TCriteria): _fGroupBy<TSources, TFields>;
-    whereRaw<RAW extends string>(where: NO_START_WITH_WHERE<RAW>): _fGroupBy<TSources, TFields>;
-}
-type GetFieldsFromTable<TDBBase extends TTableSources> = Extract<DATABASE, {
-    table: GetRealTableNames<TDBBase>;
-}>["fields"];
-type GetColsBaseTable<TDBBase extends TTableSources> = TDBBase extends string ? keyof GetFieldsFromTable<TDBBase> : keyof GetFieldsFromTable<TDBBase[0]>;
-type GetJoinCols<TDBBase extends TTableSources> = TDBBase extends string ? IterateFields<TDBBase, IsString<GetColsBaseTable<TDBBase>>> : IterateFields<TDBBase[1], IsString<GetColsBaseTable<TDBBase[0]>>>;
-type IterateFields<TDBBase extends TTableSources, F extends string> = `${TDBBase extends string ? TDBBase : TDBBase[1]}.${F}`;
-type Relations<Table extends TTableSources> = Extract<DATABASE, {
-    table: GetRealTableNames<Table>;
-}>["relations"];
-type AvailableJoins<Tables extends Array<TTableSources>, acc extends TTableSources = never> = Tables extends [infer T extends TTableSources, ...infer Rest extends Array<TTableSources>] ? AvailableJoins<Rest, acc | keyof Relations<T>> : acc;
-type GetRealTableNames<Tables extends TTableSources> = Tables extends any ? Tables extends string ? Tables : Tables[0] : never;
-type GetAliasTableNames<Tables extends TTableSources> = Tables extends any ? Tables extends string ? Tables : Tables[1] : never;
-type SafeJoins<TNewJoin extends TTables, TJoins extends TArrSources, TRelations = Relations<TNewJoin>> = {
-    [k in keyof TRelations as Filter<k, GetRealTableNames<TJoins[number]>>]: TRelations[k];
-};
-type ToUnion<TJoins extends TArrSources> = TJoins[number];
-type MapJoinsToKnownTables<TSafeJoins extends Record<string, unknown>, TJoins extends TArrSources> = {
-    [k in ToUnion<TJoins> as GetAliasTableNames<k>]: TSafeJoins[GetRealTableNames<k>];
-};
-type CombineToString<A extends unknown, T extends unknown> = A extends string ? T extends string ? `${T}.${A}` : never : never;
-type GetUnionOfRelations<TSafe> = {
-    [T in keyof TSafe]: {
-        [TLocal in keyof TSafe[T]]: [
-            TLocal,
-            T extends string ? TSafe[T][TLocal] extends Array<string> ? CombineToString<TSafe[T][TLocal][number], T> : never : never
-        ];
-    }[keyof TSafe[T]];
-}[keyof TSafe];
-type ValidStringTuple<T> = T extends [string, string] ? T : never;
-type find<TJoinCols extends [string, string], toFind extends string> = TJoinCols extends [infer col1, infer col2] ? col1 extends toFind ? col2 : never : never;
-type RemoveNullable<T extends string> = T extends `?${infer R}` ? R : T;
-type SwapKeysAndValues<T extends Record<string, any>> = {
-    [K in keyof T as RemoveNullable<T[K]>]: K;
-};
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type ExtractTableName<T extends string> = T extends `${infer Table} ${string}` ? Table : T;
-type ExtractAlias<T extends string> = T extends `${string} ${infer Alias}` ? Alias : never;
-type FieldsByTableByType = Prettify<{
-    [Table in TTables]: SwapKeysAndValues<_db[Table]["fields"]>;
-}>;
-type GetTypes = {
-    [Type in keyof FieldsByTableByType as keyof FieldsByTableByType[Type]]: {};
-};
-type FieldsByTypeByTable = Prettify<{
-    [Type in keyof GetTypes]: {
-        [Table in keyof FieldsByTableByType as [FieldsByTableByType[Table][Filter<keyof FieldsByTableByType[Table], Type>]] extends [never] ? never : Table]: FieldsByTableByType[Table][Filter<keyof FieldsByTableByType[Table], Type>];
-    };
-}>;
-type GetColumnType<Table extends TTableSources, Col1 extends keyof _db[Table extends string ? Table : `Come back to 8`]["fields"]> = RemoveNullChar<IsString<_db[Table extends string ? Table : `Come back to 9`]["fields"][Col1]>>;
-type GetJoinOnColsType<Type extends string, TSources extends TArrSources> = GetJoinColsType<TSources[number], Type>;
-type GetColsFromTableType<TDBBase extends TTableSources, Type extends string> = FieldsByTypeByTable[Loop<keyof FieldsByTypeByTable, Type>][GetRealTableNames<TDBBase>];
-type Loop<Keys extends string, Type extends string> = Keys extends Type ? Type : never;
-type GetJoinColsType<TDBBase extends TTableSources, Type extends string> = IterateFields<TDBBase, IsString<GetColsFromTableType<TDBBase, Type>>>;
-type TFieldsType = Record<string, Record<string, any>>;
-declare class _fJoin<TSources extends TArrSources, TFields extends TFieldsType> extends _fWhere<TSources, TFields> {
-    join<const Table extends AvailableJoins<TSources>, TJoinCols extends [string, string] = ValidStringTuple<GetUnionOfRelations<MapJoinsToKnownTables<SafeJoins<Table, TSources>, TSources>>>, TCol1 extends TJoinCols[0] = never, TAlias extends string = never>(options: {
-        table: Table;
-        src: TCol1;
-        on: find<TJoinCols, TCol1>;
-        alias?: TAlias;
-    }): _fJoin<[...TSources, [TAlias] extends [undefined] ? Table : [Table, TAlias]], Prettify<TFields & Record<[TAlias] extends [undefined] ? Table : TAlias, GetFieldsFromTable<Table>>>>;
-    join<const TableInput extends `${AvailableJoins<TSources>}` | `${AvailableJoins<TSources>} ${string}`, Table extends AvailableJoins<TSources> = ExtractTableName<TableInput> & AvailableJoins<TSources>, TAlias extends string | never = ExtractAlias<TableInput>, TJoinCols extends [string, string] = ValidStringTuple<GetUnionOfRelations<MapJoinsToKnownTables<SafeJoins<Table, TSources>, TSources>>>, TCol1 extends TJoinCols[0] = never>(table: TableInput, field: TCol1, reference: find<TJoinCols, TCol1>): _fJoin<[...TSources, [TAlias] extends [never] ? Table : [Table, TAlias]], Prettify<TFields & Record<[TAlias] extends [never] ? Table : TAlias, GetFieldsFromTable<Table>>>>;
-    joinUnsafeTypeEnforced<const Table extends AvailableJoins<TSources>, TCol1 extends GetColsBaseTable<Table>, TCol2 extends GetJoinOnColsType<GetColumnType<Table, TCol1>, [...TSources, Table]>, TAlias extends string = never>(options: {
-        table: Table;
-        src: TCol1;
-        on: TCol2;
-        alias?: TAlias;
-    }): _fJoin<[...TSources, [TAlias] extends [undefined] ? Table : [Table, TAlias]], Prettify<TFields & Record<[TAlias] extends [undefined] ? Table : TAlias, GetFieldsFromTable<Table>>>>;
-    joinUnsafeTypeEnforced<const TableInput extends `${AvailableJoins<TSources>}` | `${AvailableJoins<TSources>} ${string}`, Table extends AvailableJoins<TSources> = ExtractTableName<TableInput> & AvailableJoins<TSources>, TAlias extends string | never = ExtractAlias<TableInput>, TCol1 extends GetColsBaseTable<Table> = GetColsBaseTable<Table>, TCol2 extends GetJoinOnColsType<GetColumnType<Table, TCol1>, [...TSources, Table]> = GetJoinOnColsType<GetColumnType<Table, TCol1>, [...TSources, Table]>>(table: TableInput, field: TCol1, reference: TCol2): _fJoin<[...TSources, [TAlias] extends [never] ? Table : [Table, TAlias]], Prettify<TFields & Record<[TAlias] extends [undefined] ? Table : TAlias, GetFieldsFromTable<Table>>>>;
-    joinUnsafeIgnoreType<const Table extends AvailableJoins<TSources>, TCol1 extends GetColsBaseTable<Table>, TCol2 extends GetJoinCols<TSources[number]>, TAlias extends string = never>(options: {
-        table: Table;
-        src: TCol1;
-        on: TCol2;
-        alias?: TAlias;
-    }): _fJoin<[...TSources, [TAlias] extends [never] ? Table : [Table, TAlias]], TFields & Record<Table, GetFieldsFromTable<Table>>>;
-    joinUnsafeIgnoreType<const TableInput extends `${AvailableJoins<TSources>}` | `${AvailableJoins<TSources>} ${string}`, Table extends AvailableJoins<TSources> = ExtractTableName<TableInput> & AvailableJoins<TSources>, TAlias extends string | never = ExtractAlias<TableInput>, TCol1 extends GetColsBaseTable<Table> = GetColsBaseTable<Table>, TCol2 extends GetJoinCols<TSources[number]> = GetJoinCols<TSources[number]>>(table: TableInput, field: TCol1, reference: TCol2): _fJoin<[...TSources, [TAlias] extends [never] ? Table : [Table, TAlias]], TFields & Record<Table, GetFieldsFromTable<Table>>>;
-}
-declare const _default: {
-    client: {
-        $from<const T extends TTables | `${TTables} ${string}`, Table extends TTables = ExtractTableName<T>, TAlias extends string | never = ExtractAlias<T>>(table: T): _fJoin<[TAlias] extends [never] ? [Table] : [[Table, TAlias]], Record<GetAliasTableNames<([TAlias] extends [never] ? [Table] : [[Table, TAlias]])[0]>, GetFieldsFromTable<Table>>>;
-    };
-};
-
-export { type DBType, type GetUnionOfRelations, type JSONArray, type JSONObject, type JSONPrimitive, type JSONValue, type MapJoinsToKnownTables, type RemoveNullChar, type SafeJoins, type TTableSources, type TTables, _default as default };