@zodec/core 0.0.1

package/README.md

@@ -0,0 +1,110 @@
+# @zodec/core
+
+zodec = zod<functional-schema> ++ class-validator<clean-declarative-style> 
+
+Define schemas inline within the class definitions
+
+A TypeScript library that generates model schemas(zod) using *decorators*.
+and *keep validation logic close to your models*.
+
+
+## Installation
+
+```bash
+npm install @zodec/core zod reflect-metadata
+```
+
+## Usage
+
+### Basic Example: Pizza Schema
+
+Decorate the class attributes with `@zatt` decorators to automatically generate a Zod schema:
+
+```typescript
+import "reflect-metadata";
+import { z } from "zod";
+import { zatt, Zodec } from "@zodec/core";
+
+class Pizza {
+  @zatt(z.string())
+  name: string;
+
+  @zatt(z.number().positive())
+  price: number;
+
+  @zatt(z.array(z.string()))
+  toppings: string[];
+
+  @zatt(z.boolean().optional())
+  isVeg?: boolean;
+}
+
+// Get the generated schema
+const pizzaSchema = Zodec.of(Pizza);
+
+// Validate data
+const result = pizzaSchema.parse({
+  name: "Margherita",
+  price: 12.99,
+  toppings: ["mozzarella", "tomato", "basil"],
+  isVeg: false
+});
+```
+
+
+
+
+### Decorators
+
+#### `@zclass(zodSchema)`
+Apply a pre-made Zod schema object to an entire class. Use this when you've already created a complete schema elsewhere:
+
+```typescript
+const myClassSchema = z.object({
+  name: z.string(),
+  age: z.number()
+});
+
+@zclass(myClassSchema)
+class MyClass {
+}
+```
+
+#### `@zatt(zodSchema)`
+Decorate individual class properties with their Zod schemas. Each property gets its own validation rules:
+
+```typescript
+class Product {
+  @zatt(z.string().min(1))
+  name: string;
+
+  @zatt(z.number().positive())
+  price: number;
+}
+```
+
+
+## Getting the Schema
+
+Use `Zodec.of()` to retrieve the generated schema:
+
+```typescript
+const schema = Zodec.of(Pizza);
+
+if(schema){
+    const validated = schema.parse(data);
+}
+```
+
+> ⚠️ This library requires `reflect-metadata` to be imported once in your app entry point.
+
+
+## Benefits
+
+- **Type-safe**: Leverages TypeScript types alongside Zod validation
+- **Declarative**: Define schemas inline with your class definitions
+- **Reusable**: Generate schemas once, validate multiple times
+- **Composable**: Nest objects and arrays with full Zod support
+
+
+

package/dist/constants.zodec.d.ts

@@ -0,0 +1,3 @@
+export declare const ZODEC__SCHEMA = "zodec:schema";
+export declare const ZODEC__TYPE = "zodec:type";
+//# sourceMappingURL=constants.zodec.d.ts.map

package/dist/constants.zodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.zodec.d.ts","sourceRoot":"","sources":["../src/constants.zodec.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,iBAAiB,CAAA;AAC3C,eAAO,MAAM,WAAW,eAAe,CAAA"}

package/dist/decorators/zatt.decorator.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod";
+/**
+ * zatt: zod attribute
+ * decorate a property with a zod schema
+ * this extends the class schema
+ *  > use .describe() | for descriptions
+ * @param attributeSchema
+ * @returns
+ */
+export declare function zatt<T>(attributeSchema: z.ZodType<T>): PropertyDecorator;
+//# sourceMappingURL=zatt.decorator.d.ts.map

package/dist/decorators/zatt.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zatt.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/zatt.decorator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAuBxE"}

package/dist/decorators/zclass.decorator.d.ts

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+import * as z from 'zod';
+export declare function zclass(schema: z.ZodType<any>): ClassDecorator;
+//# sourceMappingURL=zclass.decorator.d.ts.map

package/dist/decorators/zclass.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zclass.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/zclass.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,wBAAgB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,cAAc,CAW7D"}

package/dist/index.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/zodec/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ZODEC__SCHEMA: () => ZODEC__SCHEMA,
+  ZODEC__TYPE: () => ZODEC__TYPE,
+  Zodec: () => Zodec,
+  ZodifyProvider: () => ZodifyProvider,
+  zatt: () => zatt,
+  zclass: () => zclass
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/zodec/core/src/zodec.ts
+var import_reflect_metadata = require("reflect-metadata");
+
+// packages/zodec/core/src/constants.zodec.ts
+var ZODEC__SCHEMA = "zodec:schema";
+var ZODEC__TYPE = "zodec:type";
+
+// packages/zodec/core/src/zodec.ts
+var ZodifyProvider = class {
+};
+var Zodec = class {
+  static of(target) {
+    return Reflect.getMetadata(ZODEC__SCHEMA, target);
+  }
+};
+
+// packages/zodec/core/src/decorators/zatt.decorator.ts
+var z = __toESM(require("zod"), 1);
+function zatt(attributeSchema) {
+  return (target, propertyKey) => {
+    try {
+      let targetSchema = Reflect.getMetadata(ZODEC__SCHEMA, target.constructor);
+      if (!targetSchema) {
+        targetSchema = z.object({});
+      }
+      if (attributeSchema) {
+        targetSchema = targetSchema.extend({
+          [propertyKey.toString()]: attributeSchema
+        });
+      }
+      Reflect.defineMetadata(ZODEC__SCHEMA, targetSchema, target.constructor);
+    } catch (ex) {
+      console.error("zatt/decorator/ex", ex);
+    }
+  };
+}
+
+// packages/zodec/core/src/decorators/zclass.decorator.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+function zclass(schema) {
+  return (target) => {
+    Reflect.defineMetadata(ZODEC__SCHEMA, schema, target);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZODEC__SCHEMA,
+  ZODEC__TYPE,
+  Zodec,
+  ZodifyProvider,
+  zatt,
+  zclass
+});

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from 'src/zodec';
+export * from 'src/decorators/zatt.decorator';
+export * from 'src/decorators/zclass.decorator';
+export * from 'src/constants.zodec';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,52 @@
+// packages/zodec/core/src/zodec.ts
+import "reflect-metadata";
+
+// packages/zodec/core/src/constants.zodec.ts
+var ZODEC__SCHEMA = "zodec:schema";
+var ZODEC__TYPE = "zodec:type";
+
+// packages/zodec/core/src/zodec.ts
+var ZodifyProvider = class {
+};
+var Zodec = class {
+  static of(target) {
+    return Reflect.getMetadata(ZODEC__SCHEMA, target);
+  }
+};
+
+// packages/zodec/core/src/decorators/zatt.decorator.ts
+import * as z from "zod";
+function zatt(attributeSchema) {
+  return (target, propertyKey) => {
+    try {
+      let targetSchema = Reflect.getMetadata(ZODEC__SCHEMA, target.constructor);
+      if (!targetSchema) {
+        targetSchema = z.object({});
+      }
+      if (attributeSchema) {
+        targetSchema = targetSchema.extend({
+          [propertyKey.toString()]: attributeSchema
+        });
+      }
+      Reflect.defineMetadata(ZODEC__SCHEMA, targetSchema, target.constructor);
+    } catch (ex) {
+      console.error("zatt/decorator/ex", ex);
+    }
+  };
+}
+
+// packages/zodec/core/src/decorators/zclass.decorator.ts
+import "reflect-metadata";
+function zclass(schema) {
+  return (target) => {
+    Reflect.defineMetadata(ZODEC__SCHEMA, schema, target);
+  };
+}
+export {
+  ZODEC__SCHEMA,
+  ZODEC__TYPE,
+  Zodec,
+  ZodifyProvider,
+  zatt,
+  zclass
+};

package/dist/zodec.d.ts

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import { ZodType } from "zod";
+export declare class ZodifyProvider {
+}
+export declare class Zodec {
+    static of(target: any): ZodType<any> | undefined;
+}
+//# sourceMappingURL=zodec.d.ts.map

package/dist/zodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodec.d.ts","sourceRoot":"","sources":["../src/zodec.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAK9B,qBAAa,cAAc;CAE1B;AAID,qBAAa,KAAK;IACd,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS;CAGnD"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@zodec/core",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "name": "zodec-core",
+    "targets": {
+      "build": {
+        "executor": "@nx/esbuild:esbuild",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "packages/zodec/core/dist",
+          "main": "packages/zodec/core/src/index.ts",
+          "tsConfig": "packages/zodec/core/tsconfig.lib.json",
+          "format": [
+            "esm",
+            "cjs"
+          ],
+          "declarationRootDir": "packages/zodec/core/src"
+        }
+      }
+    }
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "zod": "^4.3.5",
+    "reflect-metadata": "^0.1.14"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}