prisma-ts-select 0.0.34 → 0.1.2

package/built/extend.js

@@ -1,678 +0,0 @@
-import { Prisma } from '@prisma/client/extension';
-import { match, P } from 'ts-pattern';
-
-const DB = {
-  "User": {
-    "fields": {
-      "id": "Int",
-      "email": "String",
-      "name": "?String"
-    },
-    "relations": {
-      "Post": {
-        "id": [
-          "authorId",
-          "lastModifiedById"
-        ]
-      },
-      "LikedPosts": {
-        "id": [
-          "authorId"
-        ]
-      }
-    }
-  },
-  "Post": {
-    "fields": {
-      "id": "Int",
-      "title": "String",
-      "content": "?String",
-      "published": "Boolean",
-      "authorId": "Int",
-      "lastModifiedById": "Int"
-    },
-    "relations": {
-      "User": {
-        "authorId": [
-          "id"
-        ],
-        "lastModifiedById": [
-          "id"
-        ]
-      },
-      "PostsImages": {
-        "id": [
-          "postId"
-        ]
-      },
-      "LikedPosts": {
-        "id": [
-          "postId"
-        ]
-      }
-    }
-  },
-  "PostsImages": {
-    "fields": {
-      "id": "Int",
-      "url": "String",
-      "postId": "Int"
-    },
-    "relations": {
-      "Post": {
-        "postId": [
-          "id"
-        ]
-      }
-    }
-  },
-  "LikedPosts": {
-    "fields": {
-      "id": "Int",
-      "postId": "Int",
-      "authorId": "Int"
-    },
-    "relations": {
-      "Post": {
-        "postId": [
-          "id"
-        ]
-      },
-      "User": {
-        "authorId": [
-          "id"
-        ]
-      }
-    }
-  },
-  "Employee": {
-    "fields": {
-      "id": "Int",
-      "name": "String",
-      "managerId": "?Int"
-    },
-    "relations": {
-      "Employee": {
-        "managerId": [
-          "id"
-        ],
-        "id": [
-          "managerId"
-        ]
-      },
-      "_ManagerSubordinates": {
-        "id": [
-          "A"
-        ]
-      }
-    }
-  },
-  "_ManagerSubordinates": {
-    "fields": {
-      "A": "Int",
-      "B": ""
-    },
-    "relations": {
-      "Employee": {
-        "A": [
-          "id"
-        ]
-      }
-    }
-  },
-  "MFId_Category": {
-    "fields": {
-      "id": "Int",
-      "name": "String"
-    },
-    "relations": {
-      "MFId_CategoryPost": {
-        "id": [
-          "categoryId"
-        ]
-      }
-    }
-  },
-  "MFId_CategoryPost": {
-    "fields": {
-      "categoryId": "Int",
-      "postId": "Int"
-    },
-    "relations": {
-      "MFId_Category": {
-        "categoryId": [
-          "id"
-        ]
-      },
-      "MFId_Post": {
-        "postId": [
-          "id"
-        ]
-      }
-    }
-  },
-  "MFId_Post": {
-    "relations": {
-      "MFId_CategoryPost": {
-        "id": [
-          "postId"
-        ]
-      }
-    },
-    "fields": {
-      "id": "Int",
-      "title": "String"
-    }
-  },
-  "M2M_Post": {
-    "fields": {
-      "id": "Int",
-      "title": "String"
-    },
-    "relations": {
-      "_M2M_CategoryToM2M_Post": {
-        "id": [
-          "B"
-        ]
-      }
-    }
-  },
-  "_M2M_CategoryToM2M_Post": {
-    "fields": {
-      "A": "Int",
-      "B": "Int"
-    },
-    "relations": {
-      "M2M_Post": {
-        "B": [
-          "id"
-        ]
-      },
-      "M2M_Category": {
-        "A": [
-          "id"
-        ]
-      }
-    }
-  },
-  "M2M_Category": {
-    "fields": {
-      "id": "Int",
-      "name": "String"
-    },
-    "relations": {
-      "_M2M_CategoryToM2M_Post": {
-        "id": [
-          "A"
-        ]
-      }
-    }
-  },
-  "M2M_NC_Category": {
-    "fields": {
-      "id": "Int",
-      "name": "String"
-    },
-    "relations": {
-      "_M2M_NC": {
-        "id": [
-          "A"
-        ]
-      }
-    }
-  },
-  "_M2M_NC": {
-    "fields": {
-      "A": "Int",
-      "B": "Int"
-    },
-    "relations": {
-      "M2M_NC_Category": {
-        "A": [
-          "id"
-        ]
-      },
-      "M2M_NC_Post": {
-        "B": [
-          "id"
-        ]
-      }
-    }
-  },
-  "M2M_NC_Post": {
-    "fields": {
-      "id": "Int",
-      "title": "String"
-    },
-    "relations": {
-      "_M2M_NC": {
-        "id": [
-          "B"
-        ]
-      }
-    }
-  },
-  "MMM_Category": {
-    "fields": {
-      "id": "Int",
-      "name": "String"
-    },
-    "relations": {
-      "_M2M_NC_M1": {
-        "id": [
-          "A"
-        ]
-      },
-      "_M2M_NC_M2": {
-        "id": [
-          "A"
-        ]
-      }
-    }
-  },
-  "_M2M_NC_M1": {
-    "fields": {
-      "A": "Int",
-      "B": "Int"
-    },
-    "relations": {
-      "MMM_Category": {
-        "A": [
-          "id"
-        ]
-      },
-      "MMM_Post": {
-        "B": [
-          "id"
-        ]
-      }
-    }
-  },
-  "_M2M_NC_M2": {
-    "fields": {
-      "A": "Int",
-      "B": "Int"
-    },
-    "relations": {
-      "MMM_Category": {
-        "A": [
-          "id"
-        ]
-      },
-      "MMM_Post": {
-        "B": [
-          "id"
-        ]
-      }
-    }
-  },
-  "MMM_Post": {
-    "fields": {
-      "id": "Int",
-      "title": "String"
-    },
-    "relations": {
-      "_M2M_NC_M1": {
-        "id": [
-          "B"
-        ]
-      },
-      "_M2M_NC_M2": {
-        "id": [
-          "B"
-        ]
-      }
-    }
-  }
-};
-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(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(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 = Prisma.getExtensionContext(this);
-      const [base, ...aliases] = table.split(" ");
-      return new DbSelect(client).from(base.trim(), aliases.join().trim() || void 0);
-    }
-  }
-};
-
-export { extend_default as default };