@fitzzero/quickdraw-core 1.2.1 → 2.1.0

package/eslint-plugin-quickdraw/index.mjs

@@ -0,0 +1,14 @@
+import noDirectPrismaMutations from "./rules/no-direct-prisma-mutations.mjs"
+import requireZodSchema from "./rules/require-zod-schema.mjs"
+import noServiceMethodRecord from "./rules/no-service-method-record.mjs"
+import noUnsafePayloadCast from "./rules/no-unsafe-payload-cast.mjs"
+
+/** @type {import('eslint').ESLint.Plugin} */
+export default {
+  rules: {
+    "no-direct-prisma-mutations": noDirectPrismaMutations,
+    "require-zod-schema": requireZodSchema,
+    "no-service-method-record": noServiceMethodRecord,
+    "no-unsafe-payload-cast": noUnsafePayloadCast,
+  },
+}

package/eslint-plugin-quickdraw/rules/no-direct-prisma-mutations.mjs

@@ -0,0 +1,49 @@
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow direct Prisma create/update/delete in service methods. Use this.create(), this.update(), this.delete() instead for proper event emission.",
+    },
+    messages: {
+      noDirectMutation:
+        "Use this.{{ method }}() from BaseService instead of this.prisma.{{ model }}.{{ method }}(). " +
+        "BaseService methods auto-emit updates to subscribers.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const MUTATION_METHODS = new Set(["create", "update", "delete"])
+
+    return {
+      CallExpression(node) {
+        const callee = node.callee
+        if (callee.type !== "MemberExpression") return
+        if (callee.property.type !== "Identifier") return
+
+        const methodName = callee.property.name
+        if (!MUTATION_METHODS.has(methodName)) return
+
+        const obj = callee.object
+        if (obj.type !== "MemberExpression") return
+
+        const parentObj = obj.object
+        if (parentObj.type !== "MemberExpression") return
+        if (parentObj.property.type !== "Identifier") return
+        if (parentObj.property.name !== "prisma") return
+
+        if (parentObj.object.type !== "ThisExpression") return
+
+        const modelName =
+          obj.property.type === "Identifier" ? obj.property.name : "model"
+
+        context.report({
+          node,
+          messageId: "noDirectMutation",
+          data: { method: methodName, model: modelName },
+        })
+      },
+    }
+  },
+}

package/eslint-plugin-quickdraw/rules/no-service-method-record.mjs

@@ -0,0 +1,35 @@
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow using & ServiceMethodsRecord intersection on BaseService generics. " +
+        "This escape hatch defeats type safety by allowing any method name.",
+    },
+    messages: {
+      noServiceMethodRecord:
+        "Remove '& ServiceMethodsRecord' from the BaseService generic. " +
+        "Use the concrete service methods type directly for full type safety.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      TSIntersectionType(node) {
+        for (const member of node.types) {
+          if (
+            member.type === "TSTypeReference" &&
+            member.typeName?.type === "Identifier" &&
+            member.typeName.name === "ServiceMethodsRecord"
+          ) {
+            context.report({
+              node: member,
+              messageId: "noServiceMethodRecord",
+            })
+          }
+        }
+      },
+    }
+  },
+}

package/eslint-plugin-quickdraw/rules/no-unsafe-payload-cast.mjs

@@ -0,0 +1,41 @@
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Warn on 'as z.infer<typeof ...>' casts in service handlers. " +
+        "These are usually unnecessary when types flow correctly from defineMethod.",
+    },
+    messages: {
+      noUnsafePayloadCast:
+        "Avoid casting payload with 'as z.infer<typeof ...>'. " +
+        "The payload should be properly typed through defineMethod's generic constraint.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      TSAsExpression(node) {
+        const typeAnnotation = node.typeAnnotation
+        if (typeAnnotation.type !== "TSTypeReference") return
+        if (typeAnnotation.typeName?.type !== "TSQualifiedName") return
+
+        const left = typeAnnotation.typeName.left
+        const right = typeAnnotation.typeName.right
+
+        if (
+          left.type === "Identifier" &&
+          left.name === "z" &&
+          right.type === "Identifier" &&
+          right.name === "infer"
+        ) {
+          context.report({
+            node,
+            messageId: "noUnsafePayloadCast",
+          })
+        }
+      },
+    }
+  },
+}

package/eslint-plugin-quickdraw/rules/require-zod-schema.mjs

@@ -0,0 +1,60 @@
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Warn when defineMethod() is called without a Zod schema option. All user-facing methods should validate payloads.",
+    },
+    messages: {
+      missingSchema:
+        "defineMethod('{{ methodName }}') is missing a Zod schema. " +
+        "Add { schema: mySchema } as the 4th argument for payload validation.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee
+        if (callee.type !== "MemberExpression") return
+        if (callee.property.type !== "Identifier") return
+        if (callee.property.name !== "defineMethod") return
+        if (callee.object.type !== "ThisExpression") return
+
+        const methodNameArg = node.arguments[0]
+        const methodName =
+          methodNameArg?.type === "Literal"
+            ? String(methodNameArg.value)
+            : "unknown"
+
+        const optionsArg = node.arguments[3]
+
+        if (!optionsArg) {
+          context.report({
+            node,
+            messageId: "missingSchema",
+            data: { methodName },
+          })
+          return
+        }
+
+        if (optionsArg.type === "ObjectExpression") {
+          const hasSchema = optionsArg.properties.some(
+            (p) =>
+              p.type === "Property" &&
+              p.key.type === "Identifier" &&
+              p.key.name === "schema"
+          )
+          if (!hasSchema) {
+            context.report({
+              node,
+              messageId: "missingSchema",
+              data: { methodName },
+            })
+          }
+        }
+      },
+    }
+  },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitzzero/quickdraw-core",
-  "version": "1.2.1",
+  "version": "2.1.0",
   "description": "Fast fullstack patterns for real-time applications with Socket.io and TanStack Query",
   "type": "module",
   "main": "./dist/shared/index.js",
@@ -26,11 +26,26 @@
     "./client/testing": {
       "import": "./dist/client/testing.js",
       "types": "./dist/client/testing.d.ts"
+    },
+    "./eslint-plugin": {
+      "import": "./eslint-plugin-quickdraw/index.mjs"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "eslint-plugin-quickdraw"
   ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "pnpm build"
+  },
   "keywords": [
     "socket.io",
     "tanstack-query",
@@ -96,15 +111,5 @@
   },
   "engines": {
     "node": ">=20"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts,.tsx",
-    "lint:fix": "eslint src --ext .ts,.tsx --fix",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
   }
-}
+}