prisma-ts-select 0.0.33

package/dist/extend/extend.js

@@ -0,0 +1,275 @@
+import { Prisma } from '@prisma/client/extension';
+import { match, P } from '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(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;
+    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 = Prisma.getExtensionContext(this);
+      return new DbSelect(client).from(table);
+    }
+  }
+};
+
+export { extend_default as default };

package/dist/generator.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./chunk-G66FOFCO.cjs');
+

package/dist/generator.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/generator.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/generator.js

@@ -0,0 +1 @@
+import './chunk-GBXPF5FT.js';

package/package.json

@@ -0,0 +1,170 @@
+{
+  "name": "prisma-ts-select",
+  "version": "0.0.33",
+  "type": "module",
+  "bin": {
+    "prisma-ts-select": "dist/bin.cjs"
+  },
+  "main": "./dist/generator.cjs",
+  "module": "./dist/generator.js",
+  "types": "./dist/generator.d.cts",
+  "exports": {
+    "./extend": {
+      "import": {
+        "import": "./built/extend.js",
+        "require": "./built/extend.js",
+        "default": "./built/extend.js",
+        "types": "./built/extend.d.ts"
+      },
+      "require": {
+        "import": "./built/extend.cjs",
+        "require": "./built/extend.cjs",
+        "default": "./built/extend.cjs",
+        "types": "./built/extend.d.cts"
+      }
+    },
+    ".": {
+      "import": {
+        "import": "./dist/generator.mjs",
+        "default": "./dist/generator.mjs",
+        "types": "./dist/generator.d.mts"
+      },
+      "require": {
+        "import": "./dist/generator.js",
+        "require": "./dist/generator.js",
+        "default": "./dist/generator.js",
+        "types": "./dist/generator.d.ts"
+      }
+    }
+  },
+  "scripts": {
+    "bp": "pnpm build && pnpm version patch && pnpm pack",
+    "build": "pnpm exec rimraf dist && tsup",
+    "reset": "rm -rf prisma/migrations/ && prisma migrate dev --name init  && prisma generate",
+    "start": "tsx src/index.ts",
+    "prisma-upgrade": "pnpm i --save-dev prisma@latest && pnpm i @prisma/client@latest",
+    "lint:ts": "tsc --noEmit -p tsconfig.json",
+    "lint:tsw": "pnpm tsc -w",
+    "lint": "tsc --noEmit ; eslint \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0",
+    "lint:s": "eslint --config .eslintrc.style.json \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0",
+    "lint:fix": "eslint --config .eslintrc.style.json \"scripts/**/*.{j,t}s{,x}\" --cache --max-warnings=0 --fix",
+    "p:gen": "pnpm exec prisma generate",
+    "p:dbp": "pnpm exec prisma db push",
+    "p:migrate": "pnpm exec prisma migrate dev",
+    "p:update": "pnpm add -D prisma@latest && pnpm add @prisma/client@latest",
+    "test": "echo 'TODO call package/usage'",
+    "test:jest": "jest",
+    "2postinstall": "node src/scripts/postinstall.js",
+    "doc": "pnpm exec markdown-toc -i README.md"
+  },
+  "dependencies": {
+    "@prisma/generator-helper": "5.16.2",
+    "@prisma/internals": "5.16.2",
+    "ts-pattern": "^5.3.1"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Adrian Elton-Browning",
+    "email": "gingacodemonkey@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/adrianbrowning/prisma-ts-select/issues"
+  },
+  "homepage": "Link to homepage or github readme here",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adrianbrowning/prisma-ts-select"
+  },
+  "devDependencies": {
+    "@prisma/client": "5.16.1",
+    "@semantic-release/changelog": "^6.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@stylistic/eslint-plugin": "^1.5.4",
+    "@total-typescript/ts-reset": "^0.5.1",
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/humanize-duration": "^3.27.2",
+    "@types/jest": "27.0.3",
+    "@types/klaw-sync": "^6.0.1",
+    "@types/lodash": "^4.14.197",
+    "@types/node": "20.11.30",
+    "@types/object-hash": "^3.0.4",
+    "@types/prettier": "2.4.2",
+    "@typescript-eslint/eslint-plugin": "^6.19.1",
+    "@typescript-eslint/parser": "^6.19.1",
+    "eslint": "^8.47.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-simple-import-sort": "^9.0.0",
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "humanize-duration": "^3.30.0",
+    "jest": "27.4.7",
+    "klaw-sync": "^6.0.0",
+    "knip": "^5.9.4",
+    "log-with-statusbar": "^1.2.0",
+    "markdown-toc": "^1.2.0",
+    "prisma": "5.16.1",
+    "prisma-dbml-generator": "^0.10.0",
+    "prisma-docs-generator": "^0.8.0",
+    "prisma-erd-generator": "^1.11.0",
+    "progress-string": "^1.2.2",
+    "rimraf": "^6.0.1",
+    "semantic-release": "^18.0.1",
+    "ts-jest": "27.1.4",
+    "tsup": "^8.1.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.3"
+  },
+  "keywords": [
+    "prisma",
+    "generator",
+    "SQL",
+    "type-safe",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=18.17",
+    "pnpm": ">= 8.6.12"
+  },
+  "target": "node",
+  "knip": {
+    "entry": [
+      "scripts/**/*.{js,ts}"
+    ],
+    "project": [
+      "**/*.{js,ts}"
+    ],
+    "ignoreBinaries": [
+      "date"
+    ],
+    "ignoreDependencies": [
+      "prisma-.+"
+    ]
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/changelog",
+        {
+          "changelogFile": "CHANGELOG.md"
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "CHANGELOG.md",
+            "package.json"
+          ],
+          "message": "chore(release): set `package.json` to ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+        }
+      ]
+    ]
+  }
+}