prisma-ts-select 0.0.33 → 0.0.34

package/dist/extend/extend.cjs

@@ -8,8 +8,14 @@ class DbSelect {
   constructor(db) {
     this.db = db;
   }
-  from(database) {
-    return new _fJoin(this.db, { database, selects: [] });
+  from(baseTable, alias) {
+    return new _fJoin(this.db, {
+      tables: [{
+        table: baseTable,
+        alias
+      }],
+      selects: []
+    });
   }
 }
 class _fRun {
@@ -30,6 +36,9 @@ class _fRun {
   getFields() {
     return {};
   }
+  getResultType() {
+    return {};
+  }
   getSQL(formatted = false) {
     function processCondition(condition, formatted2) {
       return "(" + Object.keys(condition).map((field) => {
@@ -98,14 +107,20 @@ class _fRun {
     }
     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 ${this.values.database}`,
-      this.values.tables?.map(({
+      `FROM ${baseTable}`,
+      joins.map(({
         table,
         local,
-        remote
-      }) => `JOIN ${table} ON ${local} = ${remote}`).join(formatted ? "\n" : " ") ?? "",
+        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}`,
@@ -131,7 +146,58 @@ class _fOrderBy extends _fLimit {
   }
 }
 class _fSelect extends _fOrderBy {
-  select(select) {
+  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]
@@ -144,12 +210,15 @@ class _fSelectDistinct extends _fSelect {
   }
   selectAll() {
     const selects = function(values) {
-      if (values.tables && values.tables.length > 0) {
-        return [values.database, ...values.tables.map((t) => t.table)].reduce((acc, table) => {
+      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.database].fields);
+      return Object.keys(DB[values.tables[0].table].fields);
     }(this.values);
     return new _fOrderBy(this.db, {
       ...this.values,
@@ -220,48 +289,58 @@ class _fWhere extends _fGroupBy {
   }
 }
 class _fJoin extends _fWhere {
-  join(table, field, reference) {
-    return new _fJoin(this.db, {
-      ...this.values,
-      tables: [...this.values.tables || [], { table, local: field, remote: reference }]
-    });
-  }
-  joinUnsafeTypeEnforced(table, field, reference) {
+  // 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: `${String(table)}.${String(field)}`,
-        remote: reference
+        local,
+        remote,
+        alias: tableAlias
       }]
     });
   }
-  joinUnsafeIgnoreType(table, field, reference) {
-    return new _fJoin(this.db, {
-      ...this.values,
-      tables: [...this.values.tables || [], {
-        table,
-        local: `${String(table)}.${String(field)}`,
-        remote: reference
-      }]
-    });
+  // Implementation
+  joinUnsafeTypeEnforced(tableOrOptions, field, reference) {
+    return this.join(tableOrOptions, field, reference);
+  }
+  // Implementation
+  joinUnsafeIgnoreType(tableOrOptions, field, reference) {
+    return this.join(tableOrOptions, field, reference);
   }
-  // innerJoin(table: TTables, col1:string, col2:string){
+  // innerJoin(table: TTableSources, col1:string, col2:string){
   //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
   // }
-  // leftJoin(table: TTables, col1:string, col2:string){
+  // leftJoin(table: TTableSources, col1:string, col2:string){
   //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
   // }
-  // rightJoin(table: TTables, col1:string, col2:string){
+  // rightJoin(table: TTableSources, col1:string, col2:string){
   //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
   // }
-  // fullJoin(table: TTables, col1:string, col2:string){
+  // fullJoin(table: TTableSources, col1:string, col2:string){
   //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
   // }
-  // crossJoin(table: TTables, col1:string, col2:string){
+  // crossJoin(table: TTableSources, col1:string, col2:string){
   //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
   // }
-  // outerJoin(table: TTables, col1:string, col2:string){
+  // outerJoin(table: TTableSources, col1:string, col2:string){
   //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
   // }
 }
@@ -269,7 +348,8 @@ var extend_default = {
   client: {
     $from(table) {
       const client = extension.Prisma.getExtensionContext(this);
-      return new DbSelect(client).from(table);
+      const [base, ...aliases] = table.split(" ");
+      return new DbSelect(client).from(base.trim(), aliases.join().trim() || void 0);
     }
   }
 };

package/dist/extend/extend.d.cts

@@ -32,20 +32,26 @@ type DBType = Record<string, {
 }>;
 type Filter<a, b> = a extends b ? a : never;
 type IsString<T> = T extends string ? T : never;
-type ValidSelect<Tables extends Array<TTables>> = "*" | GetOtherColumns<Tables>;
-type GetOtherColumns<Tables extends Array<TTables>> = Tables extends [infer T extends TTables, ...infer R extends Array<TTables>] ? GetColsBaseTable<T> | GetJoinCols<R[number]> : 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 TArrSources = [TTables, ...Array<TTables>];
+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 = {
-    database: TTables;
     selectDistinct?: true;
     selects: Array<string>;
-    tables?: Array<{
+    tables: [{
+        table: TTables;
+        alias?: string;
+    }, ...Array<{
         table: TTables;
         local: string;
         remote: string;
-    }>;
+        alias?: string;
+    }>];
     limit?: number;
     offset?: number;
     where?: ClauseType;
@@ -60,6 +66,7 @@ declare class _fRun<TSources extends TArrSources, TFields extends TFieldsType, T
     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> {
@@ -68,20 +75,29 @@ declare class _fOffset<TSources extends TArrSources, TFields extends TFieldsType
 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> = Tables extends [infer T extends TTables, ...infer R extends Array<TTables>] ? GetColsBaseTable<T> | GetJoinCols<R[number]> : never;
+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>}${"" | " DESC" | " ASC"}`>): _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, TTables = TSources[number]> = Field extends "*" ? Prettify<IterateTables<TSources, TFields, IncTName>> : Field extends `${infer T extends TTables}.${infer F extends string}` ? Pick<TFields[T], F> : Pick<TFields[TSources[0]], Field>;
-type IterateTables<Tables extends Array<TTables>, TFields extends TFieldsType, IncTName extends boolean, acc extends Record<string, any> = {}> = Tables extends [infer T extends TTables, ...infer Rest extends Array<TTables>] ? [IncTName] extends [false] ? IterateTables<Rest, TFields, IncTName, acc & TFields[T]> : IterateTables<Rest, TFields, IncTName, acc & IterateTablesFromFields<T, TFields[T], IncTName>> : acc;
+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 TTables, TFields extends Record<string, string>, IncTName extends boolean> = {
-    [f in keyof TFields as GenName<Table, f, IncTName>]: TFields[f];
+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<TSelect extends ValidSelect<TSources>>(select: TSelect): _fSelect<TSources, TFields, TSelectRT & MergeItems<TSelect, TSources, TFields, false, TSources[number]> extends infer T ? { [K in keyof T]: (TSelectRT & MergeItems<TSelect, TSources, TFields, false, TSources[number]>)[K]; } : never>;
+    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<string>, acc extends Array<true> = []> = T extends [string, ...infer R extends Array<string>] ? CountKeys<R, [...acc, true]> : acc["length"];
+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>;
@@ -145,7 +161,7 @@ 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<string>, TFields extends TFieldsType, acc = {}> = T extends readonly [infer HEAD, ...infer Rest] ? HEAD extends string ? Rest extends Array<string> ? 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]>>)>> : never : acc;
+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]: {
@@ -160,18 +176,24 @@ declare class _fWhere<TSources extends TArrSources, TFields extends TFieldsType>
     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 TTables> = Extract<DATABASE, {
-    table: TDBBase;
+type GetFieldsFromTable<TDBBase extends TTableSources> = Extract<DATABASE, {
+    table: GetRealTableNames<TDBBase>;
 }>["fields"];
-type GetColsBaseTable<TDBBase extends TTables> = TDBBase extends any ? keyof GetFieldsFromTable<TDBBase> : never;
-type GetJoinCols<TDBBase extends TTables> = TDBBase extends any ? IterateFields<TDBBase, IsString<GetColsBaseTable<TDBBase>>> : never;
-type IterateFields<TDBBase extends TTables, F extends string> = `${TDBBase}.${F}`;
-type Relations<Table extends TTables> = Extract<DATABASE, {
-    table: Table;
+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<TTables>, acc extends TTables = never> = Tables extends [infer T extends TTables, ...infer Rest extends Array<TTables>] ? AvailableJoins<Rest, acc | keyof Relations<T>> : acc;
-type SafeJoins<TNewJoin extends TTables, TJoins extends Array<TTables>, TRelations = Relations<TNewJoin>> = {
-    [k in keyof TRelations as Filter<k, TJoins[number]>]: TRelations[k];
+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> = {
@@ -183,7 +205,7 @@ type GetUnionOfRelations<TSafe> = {
     }[keyof TSafe[T]];
 }[keyof TSafe];
 type ValidStringTuple<T> = T extends [string, string] ? T : never;
-type find<T extends [string, string], toFind extends string> = T extends [infer col1, infer col2] ? col1 extends toFind ? col2 : never : 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;
@@ -191,6 +213,8 @@ type SwapKeysAndValues<T extends Record<string, any>> = {
 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"]>;
 }>;
@@ -202,21 +226,39 @@ type FieldsByTypeByTable = Prettify<{
         [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 TTables, Col1 extends keyof _db[Table]["fields"]> = RemoveNullChar<IsString<_db[Table]["fields"][Col1]>>;
-type GetJoinOnColsType<Type extends string, TSources extends Array<TTables>> = GetJoinColsType<TSources[number], Type>;
-type GetColsFromTableType<TDBBase extends TTables, Type extends string> = FieldsByTypeByTable[Loop<keyof FieldsByTypeByTable, Type>][TDBBase];
+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 TTables, Type extends string> = IterateFields<TDBBase, IsString<GetColsFromTableType<TDBBase, Type>>>;
+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<Table extends AvailableJoins<TSources>, TJoinCols extends [string, string] = ValidStringTuple<GetUnionOfRelations<SafeJoins<Table, TSources>>>, TCol1 extends TJoinCols[0] = never>(table: Table, field: TCol1, reference: find<TJoinCols, TCol1>): _fJoin<[...TSources, Table], TFields & Record<Table, GetFieldsFromTable<Table>> extends infer T ? { [K in keyof T]: (TFields & Record<Table, GetFieldsFromTable<Table>>)[K]; } : never>;
-    joinUnsafeTypeEnforced<Table extends AvailableJoins<TSources>, TCol1 extends GetColsBaseTable<Table>, TCol2 extends GetJoinOnColsType<GetColumnType<Table, TCol1>, [...TSources, Table]>>(table: Table, field: TCol1, reference: TCol2): _fJoin<[...TSources, Table], TFields & Record<Table, GetFieldsFromTable<Table>>>;
-    joinUnsafeIgnoreType<Table extends AvailableJoins<TSources>, TCol2 extends GetJoinCols<TSources[number]>>(table: Table, field: GetColsBaseTable<Table>, reference: TCol2): _fJoin<[...TSources, Table], TFields & Record<Table, GetFieldsFromTable<Table>>>;
+    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<T extends TTables>(table: T): _fJoin<[T], Record<T, GetFieldsFromTable<T>>>;
+        $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 RemoveNullChar, type SafeJoins, type TTables, _default as default };
+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 };