prisma-ts-select 0.0.33

package/built/extend.cjs

@@ -0,0 +1,565 @@
+'use strict';
+
+var extension = require('@prisma/client/extension');
+var tsPattern = require('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"
+        ]
+      }
+    }
+  },
+  "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(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;