prisma-ts-select 0.0.33

package/dist/chunk-G66FOFCO.cjs

@@ -0,0 +1,195 @@
+'use strict';
+
+var generatorHelper = require('@prisma/generator-helper');
+var internals = require('@prisma/internals');
+var path2 = require('path');
+var fs2 = require('fs');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+
+// src/generator.ts
+
+// src/constants.ts
+var GENERATOR_NAME = "prisma-ts-select";
+function writeFileSafely(writeLocation, content) {
+  fs2__default.default.mkdirSync(path2__default.default.dirname(writeLocation), {
+    recursive: true
+  });
+  fs2__default.default.writeFileSync(writeLocation, content);
+}
+var require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('out.js', document.baseURI).href)));
+var SupportedProviders = {
+  sqlite: true,
+  mysql: true,
+  postgresql: true,
+  cockroachdb: false,
+  mongodb: false,
+  postgres: false,
+  sqlserver: false
+};
+generatorHelper.generatorHandler({
+  onManifest() {
+    internals.logger.info(`${GENERATOR_NAME}:Registered`);
+    return {
+      defaultOutput: "../generated",
+      prettyName: GENERATOR_NAME
+    };
+  },
+  onGenerate: async (options) => {
+    const validDS = options.datasources.map((ds) => ds.provider).filter((type) => SupportedProviders[type]);
+    if (validDS.length === 0) {
+      throw new Error(`${GENERATOR_NAME}: Supported DataSource Providers are: ${Object.entries(SupportedProviders).reduce((acc, [name, supported]) => {
+        if (!supported) return acc;
+        acc.push(name);
+        return acc;
+      }, []).join(", ")}`);
+    }
+    const modelToId = {};
+    const models = options.dmmf.datamodel.models.reduce((acc, model) => {
+      const modelObj = acc[model.name] = acc[model.name] ?? {
+        fields: {},
+        relations: {}
+      };
+      for (const field of model.fields) {
+        if (field.kind !== "object") {
+          if (field.isId) modelToId[model.name] = [field.name, field.type];
+          modelObj.fields = modelObj.fields ?? {};
+          modelObj.fields[field.name] = (!field.isRequired ? "?" : "") + field.type;
+        } else {
+          if (field.relationFromFields && field.relationFromFields.length > 0 && (field.relationToFields && field.relationToFields.length > 0)) {
+            const fieldObj = modelObj.relations[field.type] = modelObj.relations[field.type] ?? {};
+            field.relationFromFields.forEach((relationFromField, i) => {
+              if (!field.relationToFields) return;
+              const relationToField = field.relationToFields[i];
+              if (!relationToField) return;
+              fieldObj[relationFromField] = fieldObj[relationFromField] || [];
+              fieldObj[relationFromField].push(relationToField);
+              const accModel = acc[field.type] = acc[field.type] ?? {};
+              const accModelRelations = accModel.relations = accModel.relations ?? {};
+              const accModelRelationToModel = accModelRelations[model.name] = accModelRelations[model.name] ?? {};
+              const relationFromFieldList = accModelRelationToModel[relationToField] = accModelRelationToModel[relationToField] ?? [];
+              relationFromFieldList.push(relationFromField);
+            });
+          } else {
+            if (!isManyToManyRelationShip(field)) continue;
+            debugger;
+            const joinTableName = "_" + field.relationName;
+            const joinTableModel = acc[joinTableName] = acc[joinTableName] ?? {
+              fields: {
+                "A": "",
+                "B": ""
+              },
+              relations: {}
+            };
+            const abJoin = [field.type, model.name].toSorted().indexOf(model.name) === 0 ? "A" : "B";
+            const [idName, idType] = getModelId(model.name);
+            joinTableModel.fields[abJoin] = idType;
+            {
+              const mr = joinTableModel.relations[model.name] = joinTableModel.relations[model.name] ?? {};
+              const mrt = mr[abJoin] = mr[abJoin] ?? [];
+              mrt.push(idName);
+            }
+            const m = modelObj.relations[joinTableName] = modelObj.relations[joinTableName] ?? {};
+            const mf = m[idName] = m[idName] ?? [];
+            mf.push(abJoin);
+          }
+        }
+      }
+      return acc;
+    }, {});
+    const pTSSelPath = path2__default.default.dirname(require2.resolve("prisma-ts-select"));
+    internals.logger.info("pTSSelPath", pTSSelPath);
+    const srcDir = path2__default.default.join(pTSSelPath, "extend");
+    const outDir = path2__default.default.join(pTSSelPath, "..", "built");
+    {
+      const file = "extend.js";
+      const contents = fs2__default.default.readFileSync(path2__default.default.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2__default.default.join(outDir, file),
+        contents.replace(
+          "const DB = {};",
+          `const DB = ${JSON.stringify(models, null, 2)};`
+        )
+      );
+    }
+    {
+      const file = "extend.cjs";
+      const contents = fs2__default.default.readFileSync(path2__default.default.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2__default.default.join(outDir, file),
+        contents.replace(
+          "const DB = {};",
+          `const DB = ${JSON.stringify(models, null, 2)};`
+        )
+      );
+    }
+    const declaration = generateReadonlyDeclaration(models);
+    {
+      const file = "extend.d.ts";
+      const contents = fs2__default.default.readFileSync(path2__default.default.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2__default.default.join(outDir, file),
+        contents.replace("declare const DB: DBType;", declaration)
+      );
+    }
+    {
+      const file = "extend.d.cts";
+      const contents = fs2__default.default.readFileSync(path2__default.default.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2__default.default.join(outDir, file),
+        contents.replace("declare const DB: DBType;", declaration)
+      );
+    }
+    function isManyToManyRelationShip(field) {
+      if (!(field.kind === "object" && field.isList)) return false;
+      const { type, relationName } = field;
+      const typeModel = options.dmmf.datamodel.models.find((m) => m.name === type);
+      if (!typeModel) return false;
+      if (!typeModel.fields.find((f) => f.kind === "object" && f.isList && f.relationName === relationName)) return false;
+      return true;
+    }
+    function getModelId(name) {
+      if (!modelToId[name]) {
+        for (const m of options.dmmf.datamodel.models) {
+          if (m.name !== name) continue;
+          for (const f of m.fields) {
+            if (f.isId) {
+              modelToId[m.name] = [f.name, f.type];
+              break;
+            }
+          }
+        }
+      }
+      const remoteId = modelToId[name];
+      if (!remoteId) throw new Error(`Remote: Unable to find @id field for model, ${name}`);
+      return remoteId;
+    }
+  }
+});
+function generateReadonlyDeclaration(db) {
+  const traverse = (obj, level = 0) => {
+    const indent = "	".repeat(level);
+    const lines = [];
+    if (obj === null) return lines.join("\n");
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === "object" && !Array.isArray(value)) {
+        lines.push(`${indent}readonly ${key}: {`);
+        lines.push(traverse(value, level + 1));
+        lines.push(`${indent}};`);
+      } else if (Array.isArray(value)) {
+        lines.push(`${indent}readonly ${key}: [${value.map((v) => `"${v}"`).join(", ")}];`);
+      } else {
+        lines.push(`${indent}readonly ${key}: "${value}";`);
+      }
+    }
+    return lines.join("\n");
+  };
+  return `declare const DB: {
+${traverse(db, 1)}
+};`;
+}

package/dist/chunk-GBXPF5FT.js

@@ -0,0 +1,187 @@
+import { generatorHandler } from '@prisma/generator-helper';
+import { logger } from '@prisma/internals';
+import path2 from 'node:path';
+import fs2 from 'node:fs';
+import { createRequire } from 'module';
+
+// src/generator.ts
+
+// src/constants.ts
+var GENERATOR_NAME = "prisma-ts-select";
+function writeFileSafely(writeLocation, content) {
+  fs2.mkdirSync(path2.dirname(writeLocation), {
+    recursive: true
+  });
+  fs2.writeFileSync(writeLocation, content);
+}
+var require2 = createRequire(import.meta.url);
+var SupportedProviders = {
+  sqlite: true,
+  mysql: true,
+  postgresql: true,
+  cockroachdb: false,
+  mongodb: false,
+  postgres: false,
+  sqlserver: false
+};
+generatorHandler({
+  onManifest() {
+    logger.info(`${GENERATOR_NAME}:Registered`);
+    return {
+      defaultOutput: "../generated",
+      prettyName: GENERATOR_NAME
+    };
+  },
+  onGenerate: async (options) => {
+    const validDS = options.datasources.map((ds) => ds.provider).filter((type) => SupportedProviders[type]);
+    if (validDS.length === 0) {
+      throw new Error(`${GENERATOR_NAME}: Supported DataSource Providers are: ${Object.entries(SupportedProviders).reduce((acc, [name, supported]) => {
+        if (!supported) return acc;
+        acc.push(name);
+        return acc;
+      }, []).join(", ")}`);
+    }
+    const modelToId = {};
+    const models = options.dmmf.datamodel.models.reduce((acc, model) => {
+      const modelObj = acc[model.name] = acc[model.name] ?? {
+        fields: {},
+        relations: {}
+      };
+      for (const field of model.fields) {
+        if (field.kind !== "object") {
+          if (field.isId) modelToId[model.name] = [field.name, field.type];
+          modelObj.fields = modelObj.fields ?? {};
+          modelObj.fields[field.name] = (!field.isRequired ? "?" : "") + field.type;
+        } else {
+          if (field.relationFromFields && field.relationFromFields.length > 0 && (field.relationToFields && field.relationToFields.length > 0)) {
+            const fieldObj = modelObj.relations[field.type] = modelObj.relations[field.type] ?? {};
+            field.relationFromFields.forEach((relationFromField, i) => {
+              if (!field.relationToFields) return;
+              const relationToField = field.relationToFields[i];
+              if (!relationToField) return;
+              fieldObj[relationFromField] = fieldObj[relationFromField] || [];
+              fieldObj[relationFromField].push(relationToField);
+              const accModel = acc[field.type] = acc[field.type] ?? {};
+              const accModelRelations = accModel.relations = accModel.relations ?? {};
+              const accModelRelationToModel = accModelRelations[model.name] = accModelRelations[model.name] ?? {};
+              const relationFromFieldList = accModelRelationToModel[relationToField] = accModelRelationToModel[relationToField] ?? [];
+              relationFromFieldList.push(relationFromField);
+            });
+          } else {
+            if (!isManyToManyRelationShip(field)) continue;
+            debugger;
+            const joinTableName = "_" + field.relationName;
+            const joinTableModel = acc[joinTableName] = acc[joinTableName] ?? {
+              fields: {
+                "A": "",
+                "B": ""
+              },
+              relations: {}
+            };
+            const abJoin = [field.type, model.name].toSorted().indexOf(model.name) === 0 ? "A" : "B";
+            const [idName, idType] = getModelId(model.name);
+            joinTableModel.fields[abJoin] = idType;
+            {
+              const mr = joinTableModel.relations[model.name] = joinTableModel.relations[model.name] ?? {};
+              const mrt = mr[abJoin] = mr[abJoin] ?? [];
+              mrt.push(idName);
+            }
+            const m = modelObj.relations[joinTableName] = modelObj.relations[joinTableName] ?? {};
+            const mf = m[idName] = m[idName] ?? [];
+            mf.push(abJoin);
+          }
+        }
+      }
+      return acc;
+    }, {});
+    const pTSSelPath = path2.dirname(require2.resolve("prisma-ts-select"));
+    logger.info("pTSSelPath", pTSSelPath);
+    const srcDir = path2.join(pTSSelPath, "extend");
+    const outDir = path2.join(pTSSelPath, "..", "built");
+    {
+      const file = "extend.js";
+      const contents = fs2.readFileSync(path2.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2.join(outDir, file),
+        contents.replace(
+          "const DB = {};",
+          `const DB = ${JSON.stringify(models, null, 2)};`
+        )
+      );
+    }
+    {
+      const file = "extend.cjs";
+      const contents = fs2.readFileSync(path2.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2.join(outDir, file),
+        contents.replace(
+          "const DB = {};",
+          `const DB = ${JSON.stringify(models, null, 2)};`
+        )
+      );
+    }
+    const declaration = generateReadonlyDeclaration(models);
+    {
+      const file = "extend.d.ts";
+      const contents = fs2.readFileSync(path2.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2.join(outDir, file),
+        contents.replace("declare const DB: DBType;", declaration)
+      );
+    }
+    {
+      const file = "extend.d.cts";
+      const contents = fs2.readFileSync(path2.join(srcDir, file), { encoding: "utf-8" });
+      writeFileSafely(
+        path2.join(outDir, file),
+        contents.replace("declare const DB: DBType;", declaration)
+      );
+    }
+    function isManyToManyRelationShip(field) {
+      if (!(field.kind === "object" && field.isList)) return false;
+      const { type, relationName } = field;
+      const typeModel = options.dmmf.datamodel.models.find((m) => m.name === type);
+      if (!typeModel) return false;
+      if (!typeModel.fields.find((f) => f.kind === "object" && f.isList && f.relationName === relationName)) return false;
+      return true;
+    }
+    function getModelId(name) {
+      if (!modelToId[name]) {
+        for (const m of options.dmmf.datamodel.models) {
+          if (m.name !== name) continue;
+          for (const f of m.fields) {
+            if (f.isId) {
+              modelToId[m.name] = [f.name, f.type];
+              break;
+            }
+          }
+        }
+      }
+      const remoteId = modelToId[name];
+      if (!remoteId) throw new Error(`Remote: Unable to find @id field for model, ${name}`);
+      return remoteId;
+    }
+  }
+});
+function generateReadonlyDeclaration(db) {
+  const traverse = (obj, level = 0) => {
+    const indent = "	".repeat(level);
+    const lines = [];
+    if (obj === null) return lines.join("\n");
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === "object" && !Array.isArray(value)) {
+        lines.push(`${indent}readonly ${key}: {`);
+        lines.push(traverse(value, level + 1));
+        lines.push(`${indent}};`);
+      } else if (Array.isArray(value)) {
+        lines.push(`${indent}readonly ${key}: [${value.map((v) => `"${v}"`).join(", ")}];`);
+      } else {
+        lines.push(`${indent}readonly ${key}: "${value}";`);
+      }
+    }
+    return lines.join("\n");
+  };
+  return `declare const DB: {
+${traverse(db, 1)}
+};`;
+}

package/dist/extend/extend.cjs

@@ -0,0 +1,277 @@
+'use strict';
+
+var extension = require('@prisma/client/extension');
+var tsPattern = require('ts-pattern');
+
+const DB = {};
+class DbSelect {
+  constructor(db) {
+    this.db = db;
+  }
+  from(database) {
+    return new _fJoin(this.db, { database, 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 {};
+  }
+  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;
+    return [
+      this.values.selects.length === 0 ? "" : "SELECT " + (this.values.selectDistinct === true ? "DISTINCT " : "") + this.values.selects.join(", "),
+      `FROM ${this.values.database}`,
+      this.values.tables?.map(({
+        table,
+        local,
+        remote
+      }) => `JOIN ${table} ON ${local} = ${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) {
+    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 > 0) {
+        return [values.database, ...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);
+    }(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 {
+  join(table, field, reference) {
+    return new _fJoin(this.db, {
+      ...this.values,
+      tables: [...this.values.tables || [], { table, local: field, remote: reference }]
+    });
+  }
+  joinUnsafeTypeEnforced(table, field, reference) {
+    return new _fJoin(this.db, {
+      ...this.values,
+      tables: [...this.values.tables || [], {
+        table,
+        local: `${String(table)}.${String(field)}`,
+        remote: reference
+      }]
+    });
+  }
+  joinUnsafeIgnoreType(table, field, reference) {
+    return new _fJoin(this.db, {
+      ...this.values,
+      tables: [...this.values.tables || [], {
+        table,
+        local: `${String(table)}.${String(field)}`,
+        remote: reference
+      }]
+    });
+  }
+  // innerJoin(table: TTables, col1:string, col2:string){
+  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
+  // }
+  // leftJoin(table: TTables, col1:string, col2:string){
+  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
+  // }
+  // rightJoin(table: TTables, col1:string, col2:string){
+  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
+  // }
+  // fullJoin(table: TTables, col1:string, col2:string){
+  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
+  // }
+  // crossJoin(table: TTables, col1:string, col2:string){
+  //     return new _fJoin<TDBBase>(this.db, {...this.values, tables: [...this.values.tables || [], table]});
+  // }
+  // outerJoin(table: TTables, 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);
+      return new DbSelect(client).from(table);
+    }
+  }
+};
+
+module.exports = extend_default;