@nubase/core 0.1.0

package/README.md

@@ -0,0 +1,51 @@
+# @nubase/core
+
+Core schema and types for the nubase ecosystem.
+
+## Installation
+
+```bash
+npm install @nubase/core
+```
+
+## Usage
+
+```typescript
+import { BaseSchema, nu } from '@nubase/core';
+
+// Example usage of base schema
+const mySchema = new BaseSchema({
+  fields: {
+    name: { type: 'string', required: true },
+    age: { type: 'number', required: false }
+  }
+});
+
+// Example usage of nu types
+const result = nu.string().parse('hello world');
+```
+
+## Features
+
+- Type-safe schema definitions
+- Zod-based validation
+- TypeScript-first design
+- Extensible base schema system
+
+## API Reference
+
+### BaseSchema
+
+Base class for creating type-safe schemas with metadata.
+
+### nu
+
+Utility functions and types for schema validation.
+
+## Contributing
+
+Please see the main repository for contributing guidelines.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,93 @@
+interface SchemaMetadata<Output = any> {
+    label?: string;
+    description?: string;
+    defaultValue?: Output;
+}
+declare abstract class BaseSchema<Output = any> {
+    /**
+     * Phantom property used for TypeScript type inference.
+     * Does not exist at runtime.
+     * @internal
+     */
+    readonly _outputType: Output;
+    _meta: SchemaMetadata<Output>;
+    /**
+     * Replace the schema metadata with a new object.
+     * @param meta The new metadata object.
+     * @returns The schema instance for chaining.
+     */
+    meta(meta: SchemaMetadata<Output>): this;
+    /**
+     * Parses and validates the input data against the schema.
+     * Should throw an error if validation fails.
+     * @param data The data to parse.
+     * @returns The parsed data (potentially transformed).
+     */
+    abstract parse(data: any): Output;
+}
+
+declare class BooleanSchema extends BaseSchema<boolean> {
+    parse(data: any): boolean;
+}
+declare class StringSchema extends BaseSchema<string> {
+    parse(data: any): string;
+}
+declare class NumberSchema extends BaseSchema<number> {
+    parse(data: any): number;
+}
+/**
+ * Type representing the shape of an object schema (key to schema mapping).
+ */
+type ObjectShape = {
+    [key: string]: BaseSchema<any>;
+};
+/**
+ * Infers the TypeScript output type from an ObjectShape.
+ * Use mapped types to get the output type of each property schema.
+ */
+type ObjectOutput<TShape extends ObjectShape> = {
+    [K in keyof TShape]: TShape[K]['_outputType'];
+};
+declare class ObjectSchema<TShape extends ObjectShape> extends BaseSchema<ObjectOutput<TShape>> {
+    _shape: TShape;
+    constructor(shape: TShape);
+    parse(data: any): ObjectOutput<TShape>;
+}
+/**
+ * Infers the TypeScript output type from an element schema for an array.
+ */
+type ArrayOutput<TElementSchema extends BaseSchema<any>> = Array<TElementSchema['_outputType']>;
+declare class ArraySchema<TElementSchema extends BaseSchema<any>> extends BaseSchema<ArrayOutput<TElementSchema>> {
+    _element: TElementSchema;
+    constructor(elementSchema: TElementSchema);
+    parse(data: any): ArrayOutput<TElementSchema>;
+}
+type NuSchema = BooleanSchema | StringSchema | NumberSchema | ObjectSchema<any> | ArraySchema<any>;
+
+/**
+ * The main nubase schema instance.
+ * Provides factory methods to create different schema types.
+ */
+declare const nu: {
+    boolean: () => BooleanSchema;
+    /**
+     * Creates a string schema.
+     */
+    string: () => StringSchema;
+    /**
+     * Creates a number schema.
+     */
+    number: () => NumberSchema;
+    /**
+     * Creates an object schema with a defined shape.
+     * @param shape An object mapping keys to schemas.
+     */
+    object: <TShape extends ObjectShape>(shape: TShape) => ObjectSchema<TShape>;
+    /**
+     * Creates an array schema with a defined element schema.
+     * @param elementSchema The schema for elements within the array.
+     */
+    array: <TElementSchema extends BaseSchema<any>>(elementSchema: TElementSchema) => ArraySchema<TElementSchema>;
+};
+
+export { type ArrayOutput, ArraySchema, BaseSchema, BooleanSchema, type NuSchema, NumberSchema, type ObjectOutput, ObjectSchema, type ObjectShape, type SchemaMetadata, StringSchema, nu };

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+interface SchemaMetadata<Output = any> {
+    label?: string;
+    description?: string;
+    defaultValue?: Output;
+}
+declare abstract class BaseSchema<Output = any> {
+    /**
+     * Phantom property used for TypeScript type inference.
+     * Does not exist at runtime.
+     * @internal
+     */
+    readonly _outputType: Output;
+    _meta: SchemaMetadata<Output>;
+    /**
+     * Replace the schema metadata with a new object.
+     * @param meta The new metadata object.
+     * @returns The schema instance for chaining.
+     */
+    meta(meta: SchemaMetadata<Output>): this;
+    /**
+     * Parses and validates the input data against the schema.
+     * Should throw an error if validation fails.
+     * @param data The data to parse.
+     * @returns The parsed data (potentially transformed).
+     */
+    abstract parse(data: any): Output;
+}
+
+declare class BooleanSchema extends BaseSchema<boolean> {
+    parse(data: any): boolean;
+}
+declare class StringSchema extends BaseSchema<string> {
+    parse(data: any): string;
+}
+declare class NumberSchema extends BaseSchema<number> {
+    parse(data: any): number;
+}
+/**
+ * Type representing the shape of an object schema (key to schema mapping).
+ */
+type ObjectShape = {
+    [key: string]: BaseSchema<any>;
+};
+/**
+ * Infers the TypeScript output type from an ObjectShape.
+ * Use mapped types to get the output type of each property schema.
+ */
+type ObjectOutput<TShape extends ObjectShape> = {
+    [K in keyof TShape]: TShape[K]['_outputType'];
+};
+declare class ObjectSchema<TShape extends ObjectShape> extends BaseSchema<ObjectOutput<TShape>> {
+    _shape: TShape;
+    constructor(shape: TShape);
+    parse(data: any): ObjectOutput<TShape>;
+}
+/**
+ * Infers the TypeScript output type from an element schema for an array.
+ */
+type ArrayOutput<TElementSchema extends BaseSchema<any>> = Array<TElementSchema['_outputType']>;
+declare class ArraySchema<TElementSchema extends BaseSchema<any>> extends BaseSchema<ArrayOutput<TElementSchema>> {
+    _element: TElementSchema;
+    constructor(elementSchema: TElementSchema);
+    parse(data: any): ArrayOutput<TElementSchema>;
+}
+type NuSchema = BooleanSchema | StringSchema | NumberSchema | ObjectSchema<any> | ArraySchema<any>;
+
+/**
+ * The main nubase schema instance.
+ * Provides factory methods to create different schema types.
+ */
+declare const nu: {
+    boolean: () => BooleanSchema;
+    /**
+     * Creates a string schema.
+     */
+    string: () => StringSchema;
+    /**
+     * Creates a number schema.
+     */
+    number: () => NumberSchema;
+    /**
+     * Creates an object schema with a defined shape.
+     * @param shape An object mapping keys to schemas.
+     */
+    object: <TShape extends ObjectShape>(shape: TShape) => ObjectSchema<TShape>;
+    /**
+     * Creates an array schema with a defined element schema.
+     * @param elementSchema The schema for elements within the array.
+     */
+    array: <TElementSchema extends BaseSchema<any>>(elementSchema: TElementSchema) => ArraySchema<TElementSchema>;
+};
+
+export { type ArrayOutput, ArraySchema, BaseSchema, BooleanSchema, type NuSchema, NumberSchema, type ObjectOutput, ObjectSchema, type ObjectShape, type SchemaMetadata, StringSchema, nu };

package/dist/index.js

@@ -0,0 +1,178 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// schema/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArraySchema: () => ArraySchema,
+  BaseSchema: () => BaseSchema,
+  BooleanSchema: () => BooleanSchema,
+  NumberSchema: () => NumberSchema,
+  ObjectSchema: () => ObjectSchema,
+  StringSchema: () => StringSchema,
+  nu: () => nu
+});
+module.exports = __toCommonJS(index_exports);
+
+// schema/base-schema.ts
+var BaseSchema = class {
+  /**
+   * Phantom property used for TypeScript type inference.
+   * Does not exist at runtime.
+   * @internal
+   */
+  _outputType;
+  _meta = {};
+  /**
+   * Replace the schema metadata with a new object.
+   * @param meta The new metadata object.
+   * @returns The schema instance for chaining.
+   */
+  meta(meta) {
+    this._meta = meta;
+    return this;
+  }
+  // We could also add a safeParse method like Zod if needed
+  // safeParse(data: any): { success: true; data: Output } | { success: false; error: SchemaError };
+};
+
+// schema/types.ts
+var BooleanSchema = class extends BaseSchema {
+  parse(data) {
+    if (typeof data !== "boolean") {
+      throw new Error(`Expected boolean, received ${typeof data}`);
+    }
+    return data;
+  }
+};
+var StringSchema = class extends BaseSchema {
+  parse(data) {
+    if (typeof data !== "string") {
+      throw new Error(`Expected string, received ${typeof data}`);
+    }
+    return data;
+  }
+  // Add string-specific validation methods here (e.g., minLength, pattern)
+};
+var NumberSchema = class extends BaseSchema {
+  parse(data) {
+    if (typeof data !== "number" || !Number.isFinite(data)) {
+      throw new Error(`Expected number, received ${typeof data}`);
+    }
+    return data;
+  }
+  // Add number-specific validation methods here (e.g., min, max)
+};
+var ObjectSchema = class extends BaseSchema {
+  _shape;
+  constructor(shape) {
+    super();
+    this._shape = shape;
+  }
+  parse(data) {
+    if (typeof data !== "object" || data === null) {
+      throw new Error(`Expected object, received ${typeof data}`);
+    }
+    const result = {};
+    const errors = [];
+    for (const key in this._shape) {
+      if (Object.prototype.hasOwnProperty.call(this._shape, key)) {
+        const schema = this._shape[key];
+        const value = data[key];
+        try {
+          if (schema) {
+            result[key] = schema.parse(value);
+          }
+        } catch (e) {
+          errors.push(`Property "${key}": ${e.message}`);
+        }
+      }
+    }
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key) && !Object.prototype.hasOwnProperty.call(this._shape, key)) {
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Object validation failed:
+${errors.join("\n")}`);
+    }
+    return result;
+  }
+};
+var ArraySchema = class extends BaseSchema {
+  _element;
+  constructor(elementSchema) {
+    super();
+    this._element = elementSchema;
+  }
+  parse(data) {
+    if (!Array.isArray(data)) {
+      throw new Error(`Expected array, received ${typeof data}`);
+    }
+    const result = [];
+    const errors = [];
+    for (let i = 0; i < data.length; i++) {
+      try {
+        result[i] = this._element.parse(data[i]);
+      } catch (e) {
+        errors.push(`Element at index ${i}: ${e.message}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Array validation failed:
+${errors.join("\n")}`);
+    }
+    return result;
+  }
+};
+
+// schema/nu.ts
+var nu = {
+  boolean: () => new BooleanSchema(),
+  /**
+   * Creates a string schema.
+   */
+  string: () => new StringSchema(),
+  /**
+   * Creates a number schema.
+   */
+  number: () => new NumberSchema(),
+  /**
+   * Creates an object schema with a defined shape.
+   * @param shape An object mapping keys to schemas.
+   */
+  object: (shape) => new ObjectSchema(shape),
+  /**
+   * Creates an array schema with a defined element schema.
+   * @param elementSchema The schema for elements within the array.
+   */
+  array: (elementSchema) => new ArraySchema(elementSchema)
+  // Add more factory methods here (boolean, union, literal, etc.)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArraySchema,
+  BaseSchema,
+  BooleanSchema,
+  NumberSchema,
+  ObjectSchema,
+  StringSchema,
+  nu
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../schema/index.ts","../schema/base-schema.ts","../schema/types.ts","../schema/nu.ts"],"sourcesContent":["export * from './types';\nexport { BaseSchema, type SchemaMetadata } from './base-schema';\nexport * from './nu';\n","// src/schema/BaseSchema.ts\n\nimport { z } from 'zod'; // We'll need Zod later for toZod conversion\n\n// Define metadata types\nexport interface SchemaMetadata<Output = any> {\n  label?: string;\n  description?: string;\n  defaultValue?: Output;\n}\n\n// Base schema class\nexport abstract class BaseSchema<Output = any> {\n  /**\n   * Phantom property used for TypeScript type inference.\n   * Does not exist at runtime.\n   * @internal\n   */\n  readonly _outputType!: Output;\n\n  _meta: SchemaMetadata<Output> = {};\n\n  /**\n   * Replace the schema metadata with a new object.\n   * @param meta The new metadata object.\n   * @returns The schema instance for chaining.\n   */\n  meta(meta: SchemaMetadata<Output>): this {\n    this._meta = meta;\n    return this;\n  }\n\n  /**\n   * Parses and validates the input data against the schema.\n   * Should throw an error if validation fails.\n   * @param data The data to parse.\n   * @returns The parsed data (potentially transformed).\n   */\n  abstract parse(data: any): Output;\n\n  // We could also add a safeParse method like Zod if needed\n  // safeParse(data: any): { success: true; data: Output } | { success: false; error: SchemaError };\n}\n\n// Define a union type of all concrete schema types for easier handling\nexport type NuSchema = BaseSchema<any>; // This will be refined later","// src/schema/types.ts\n\nimport { BaseSchema } from './base-schema';\n\n// --- Primitive Schemas ---\n\nexport class BooleanSchema extends BaseSchema<boolean> {\n  parse(data: any): boolean {\n    if (typeof data !== 'boolean') {\n      throw new Error(`Expected boolean, received ${typeof data}`);\n    }\n    return data;\n  }\n}\n\nexport class StringSchema extends BaseSchema<string> {\n  parse(data: any): string {\n    if (typeof data !== 'string') {\n      throw new Error(`Expected string, received ${typeof data}`);\n    }\n    return data;\n  }\n  // Add string-specific validation methods here (e.g., minLength, pattern)\n}\n\nexport class NumberSchema extends BaseSchema<number> {\n  parse(data: any): number {\n    if (typeof data !== 'number' || !Number.isFinite(data)) {\n      throw new Error(`Expected number, received ${typeof data}`);\n    }\n    return data;\n  }\n  // Add number-specific validation methods here (e.g., min, max)\n}\n\n// Add more primitives like BooleanSchema, NullableSchema, OptionalSchema etc.\n\n// --- Complex Schemas ---\n\n/**\n * Type representing the shape of an object schema (key to schema mapping).\n */\nexport type ObjectShape = {\n  [key: string]: BaseSchema<any>;\n};\n\n/**\n * Infers the TypeScript output type from an ObjectShape.\n * Use mapped types to get the output type of each property schema.\n */\nexport type ObjectOutput<TShape extends ObjectShape> = {\n  [K in keyof TShape]: TShape[K]['_outputType'];\n};\n\nexport class ObjectSchema<TShape extends ObjectShape> extends BaseSchema<ObjectOutput<TShape>> {\n  _shape: TShape;\n\n  constructor(shape: TShape) {\n    super();\n    this._shape = shape;\n  }\n\n  parse(data: any): ObjectOutput<TShape> {\n    if (typeof data !== 'object' || data === null) {\n      throw new Error(`Expected object, received ${typeof data}`);\n    }\n\n    const result: any = {};\n    const errors: string[] = [];\n\n    // Validate defined properties\n    for (const key in this._shape) {\n      if (Object.prototype.hasOwnProperty.call(this._shape, key)) {\n        const schema = this._shape[key];\n        const value = (data as any)[key]; // Get value from input data\n        try {\n          if (schema) {\n            result[key] = schema.parse(value); // Recursively parse property\n          }\n        } catch (e: any) {\n          errors.push(`Property \"${key}\": ${e.message}`);\n        }\n      }\n    }\n\n    // Basic handling for extra keys (can be made configurable)\n    for (const key in data) {\n        if (Object.prototype.hasOwnProperty.call(data, key) && !Object.prototype.hasOwnProperty.call(this._shape, key)) {\n            // For now, ignore extra keys. Could throw an error or strip them.\n            // errors.push(`Unknown property \"${key}\"`);\n            // console.warn(`Warning: Unknown property \"${key}\" in object data.`);\n        }\n    }\n\n\n    if (errors.length > 0) {\n      throw new Error(`Object validation failed:\\n${errors.join('\\n')}`);\n    }\n\n    return result as ObjectOutput<TShape>;\n  }\n}\n\n/**\n * Infers the TypeScript output type from an element schema for an array.\n */\nexport type ArrayOutput<TElementSchema extends BaseSchema<any>> = Array<TElementSchema['_outputType']>;\n\n\nexport class ArraySchema<TElementSchema extends BaseSchema<any>> extends BaseSchema<ArrayOutput<TElementSchema>> {\n  _element: TElementSchema;\n\n  constructor(elementSchema: TElementSchema) {\n    super();\n    this._element = elementSchema;\n  }\n\n  parse(data: any): ArrayOutput<TElementSchema> {\n    if (!Array.isArray(data)) {\n      throw new Error(`Expected array, received ${typeof data}`);\n    }\n\n    const result: any[] = [];\n    const errors: string[] = [];\n\n    for (let i = 0; i < data.length; i++) {\n      try {\n        result[i] = this._element.parse(data[i]); // Recursively parse each element\n      } catch (e: any) {\n        errors.push(`Element at index ${i}: ${e.message}`);\n      }\n    }\n\n    if (errors.length > 0) {\n        throw new Error(`Array validation failed:\\n${errors.join('\\n')}`);\n    }\n\n    return result as ArrayOutput<TElementSchema>;\n  }\n}\n\n// Refine NuSchema union after defining concrete types\nexport type NuSchema =\n  | BooleanSchema\n  | StringSchema\n  | NumberSchema\n  // Add others like BooleanSchema\n  | ObjectSchema<any>\n  | ArraySchema<any>;","// src/nu.ts\n\nimport { BaseSchema } from \"./base-schema\";\nimport { StringSchema, NumberSchema, ObjectShape, ObjectSchema, ArraySchema, BooleanSchema } from \"./types\";\n\n\n/**\n * The main nubase schema instance.\n * Provides factory methods to create different schema types.\n */\nexport const nu = {\n  boolean : () => new BooleanSchema(),\n  /**\n   * Creates a string schema.\n   */\n  string: () => new StringSchema(),\n\n  /**\n   * Creates a number schema.\n   */\n  number: () => new NumberSchema(),\n\n  /**\n   * Creates an object schema with a defined shape.\n   * @param shape An object mapping keys to schemas.\n   */\n  object: <TShape extends ObjectShape>(shape: TShape) => new ObjectSchema(shape),\n\n  /**\n   * Creates an array schema with a defined element schema.\n   * @param elementSchema The schema for elements within the array.\n   */\n  array: <TElementSchema extends BaseSchema<any>>(elementSchema: TElementSchema) => new ArraySchema(elementSchema),\n\n  // Add more factory methods here (boolean, union, literal, etc.)\n};"],"mappings":"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","names":[]}

package/dist/index.mjs

@@ -0,0 +1,145 @@
+// schema/base-schema.ts
+var BaseSchema = class {
+  /**
+   * Phantom property used for TypeScript type inference.
+   * Does not exist at runtime.
+   * @internal
+   */
+  _outputType;
+  _meta = {};
+  /**
+   * Replace the schema metadata with a new object.
+   * @param meta The new metadata object.
+   * @returns The schema instance for chaining.
+   */
+  meta(meta) {
+    this._meta = meta;
+    return this;
+  }
+  // We could also add a safeParse method like Zod if needed
+  // safeParse(data: any): { success: true; data: Output } | { success: false; error: SchemaError };
+};
+
+// schema/types.ts
+var BooleanSchema = class extends BaseSchema {
+  parse(data) {
+    if (typeof data !== "boolean") {
+      throw new Error(`Expected boolean, received ${typeof data}`);
+    }
+    return data;
+  }
+};
+var StringSchema = class extends BaseSchema {
+  parse(data) {
+    if (typeof data !== "string") {
+      throw new Error(`Expected string, received ${typeof data}`);
+    }
+    return data;
+  }
+  // Add string-specific validation methods here (e.g., minLength, pattern)
+};
+var NumberSchema = class extends BaseSchema {
+  parse(data) {
+    if (typeof data !== "number" || !Number.isFinite(data)) {
+      throw new Error(`Expected number, received ${typeof data}`);
+    }
+    return data;
+  }
+  // Add number-specific validation methods here (e.g., min, max)
+};
+var ObjectSchema = class extends BaseSchema {
+  _shape;
+  constructor(shape) {
+    super();
+    this._shape = shape;
+  }
+  parse(data) {
+    if (typeof data !== "object" || data === null) {
+      throw new Error(`Expected object, received ${typeof data}`);
+    }
+    const result = {};
+    const errors = [];
+    for (const key in this._shape) {
+      if (Object.prototype.hasOwnProperty.call(this._shape, key)) {
+        const schema = this._shape[key];
+        const value = data[key];
+        try {
+          if (schema) {
+            result[key] = schema.parse(value);
+          }
+        } catch (e) {
+          errors.push(`Property "${key}": ${e.message}`);
+        }
+      }
+    }
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key) && !Object.prototype.hasOwnProperty.call(this._shape, key)) {
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Object validation failed:
+${errors.join("\n")}`);
+    }
+    return result;
+  }
+};
+var ArraySchema = class extends BaseSchema {
+  _element;
+  constructor(elementSchema) {
+    super();
+    this._element = elementSchema;
+  }
+  parse(data) {
+    if (!Array.isArray(data)) {
+      throw new Error(`Expected array, received ${typeof data}`);
+    }
+    const result = [];
+    const errors = [];
+    for (let i = 0; i < data.length; i++) {
+      try {
+        result[i] = this._element.parse(data[i]);
+      } catch (e) {
+        errors.push(`Element at index ${i}: ${e.message}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`Array validation failed:
+${errors.join("\n")}`);
+    }
+    return result;
+  }
+};
+
+// schema/nu.ts
+var nu = {
+  boolean: () => new BooleanSchema(),
+  /**
+   * Creates a string schema.
+   */
+  string: () => new StringSchema(),
+  /**
+   * Creates a number schema.
+   */
+  number: () => new NumberSchema(),
+  /**
+   * Creates an object schema with a defined shape.
+   * @param shape An object mapping keys to schemas.
+   */
+  object: (shape) => new ObjectSchema(shape),
+  /**
+   * Creates an array schema with a defined element schema.
+   * @param elementSchema The schema for elements within the array.
+   */
+  array: (elementSchema) => new ArraySchema(elementSchema)
+  // Add more factory methods here (boolean, union, literal, etc.)
+};
+export {
+  ArraySchema,
+  BaseSchema,
+  BooleanSchema,
+  NumberSchema,
+  ObjectSchema,
+  StringSchema,
+  nu
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../schema/base-schema.ts","../schema/types.ts","../schema/nu.ts"],"sourcesContent":["// src/schema/BaseSchema.ts\n\nimport { z } from 'zod'; // We'll need Zod later for toZod conversion\n\n// Define metadata types\nexport interface SchemaMetadata<Output = any> {\n  label?: string;\n  description?: string;\n  defaultValue?: Output;\n}\n\n// Base schema class\nexport abstract class BaseSchema<Output = any> {\n  /**\n   * Phantom property used for TypeScript type inference.\n   * Does not exist at runtime.\n   * @internal\n   */\n  readonly _outputType!: Output;\n\n  _meta: SchemaMetadata<Output> = {};\n\n  /**\n   * Replace the schema metadata with a new object.\n   * @param meta The new metadata object.\n   * @returns The schema instance for chaining.\n   */\n  meta(meta: SchemaMetadata<Output>): this {\n    this._meta = meta;\n    return this;\n  }\n\n  /**\n   * Parses and validates the input data against the schema.\n   * Should throw an error if validation fails.\n   * @param data The data to parse.\n   * @returns The parsed data (potentially transformed).\n   */\n  abstract parse(data: any): Output;\n\n  // We could also add a safeParse method like Zod if needed\n  // safeParse(data: any): { success: true; data: Output } | { success: false; error: SchemaError };\n}\n\n// Define a union type of all concrete schema types for easier handling\nexport type NuSchema = BaseSchema<any>; // This will be refined later","// src/schema/types.ts\n\nimport { BaseSchema } from './base-schema';\n\n// --- Primitive Schemas ---\n\nexport class BooleanSchema extends BaseSchema<boolean> {\n  parse(data: any): boolean {\n    if (typeof data !== 'boolean') {\n      throw new Error(`Expected boolean, received ${typeof data}`);\n    }\n    return data;\n  }\n}\n\nexport class StringSchema extends BaseSchema<string> {\n  parse(data: any): string {\n    if (typeof data !== 'string') {\n      throw new Error(`Expected string, received ${typeof data}`);\n    }\n    return data;\n  }\n  // Add string-specific validation methods here (e.g., minLength, pattern)\n}\n\nexport class NumberSchema extends BaseSchema<number> {\n  parse(data: any): number {\n    if (typeof data !== 'number' || !Number.isFinite(data)) {\n      throw new Error(`Expected number, received ${typeof data}`);\n    }\n    return data;\n  }\n  // Add number-specific validation methods here (e.g., min, max)\n}\n\n// Add more primitives like BooleanSchema, NullableSchema, OptionalSchema etc.\n\n// --- Complex Schemas ---\n\n/**\n * Type representing the shape of an object schema (key to schema mapping).\n */\nexport type ObjectShape = {\n  [key: string]: BaseSchema<any>;\n};\n\n/**\n * Infers the TypeScript output type from an ObjectShape.\n * Use mapped types to get the output type of each property schema.\n */\nexport type ObjectOutput<TShape extends ObjectShape> = {\n  [K in keyof TShape]: TShape[K]['_outputType'];\n};\n\nexport class ObjectSchema<TShape extends ObjectShape> extends BaseSchema<ObjectOutput<TShape>> {\n  _shape: TShape;\n\n  constructor(shape: TShape) {\n    super();\n    this._shape = shape;\n  }\n\n  parse(data: any): ObjectOutput<TShape> {\n    if (typeof data !== 'object' || data === null) {\n      throw new Error(`Expected object, received ${typeof data}`);\n    }\n\n    const result: any = {};\n    const errors: string[] = [];\n\n    // Validate defined properties\n    for (const key in this._shape) {\n      if (Object.prototype.hasOwnProperty.call(this._shape, key)) {\n        const schema = this._shape[key];\n        const value = (data as any)[key]; // Get value from input data\n        try {\n          if (schema) {\n            result[key] = schema.parse(value); // Recursively parse property\n          }\n        } catch (e: any) {\n          errors.push(`Property \"${key}\": ${e.message}`);\n        }\n      }\n    }\n\n    // Basic handling for extra keys (can be made configurable)\n    for (const key in data) {\n        if (Object.prototype.hasOwnProperty.call(data, key) && !Object.prototype.hasOwnProperty.call(this._shape, key)) {\n            // For now, ignore extra keys. Could throw an error or strip them.\n            // errors.push(`Unknown property \"${key}\"`);\n            // console.warn(`Warning: Unknown property \"${key}\" in object data.`);\n        }\n    }\n\n\n    if (errors.length > 0) {\n      throw new Error(`Object validation failed:\\n${errors.join('\\n')}`);\n    }\n\n    return result as ObjectOutput<TShape>;\n  }\n}\n\n/**\n * Infers the TypeScript output type from an element schema for an array.\n */\nexport type ArrayOutput<TElementSchema extends BaseSchema<any>> = Array<TElementSchema['_outputType']>;\n\n\nexport class ArraySchema<TElementSchema extends BaseSchema<any>> extends BaseSchema<ArrayOutput<TElementSchema>> {\n  _element: TElementSchema;\n\n  constructor(elementSchema: TElementSchema) {\n    super();\n    this._element = elementSchema;\n  }\n\n  parse(data: any): ArrayOutput<TElementSchema> {\n    if (!Array.isArray(data)) {\n      throw new Error(`Expected array, received ${typeof data}`);\n    }\n\n    const result: any[] = [];\n    const errors: string[] = [];\n\n    for (let i = 0; i < data.length; i++) {\n      try {\n        result[i] = this._element.parse(data[i]); // Recursively parse each element\n      } catch (e: any) {\n        errors.push(`Element at index ${i}: ${e.message}`);\n      }\n    }\n\n    if (errors.length > 0) {\n        throw new Error(`Array validation failed:\\n${errors.join('\\n')}`);\n    }\n\n    return result as ArrayOutput<TElementSchema>;\n  }\n}\n\n// Refine NuSchema union after defining concrete types\nexport type NuSchema =\n  | BooleanSchema\n  | StringSchema\n  | NumberSchema\n  // Add others like BooleanSchema\n  | ObjectSchema<any>\n  | ArraySchema<any>;","// src/nu.ts\n\nimport { BaseSchema } from \"./base-schema\";\nimport { StringSchema, NumberSchema, ObjectShape, ObjectSchema, ArraySchema, BooleanSchema } from \"./types\";\n\n\n/**\n * The main nubase schema instance.\n * Provides factory methods to create different schema types.\n */\nexport const nu = {\n  boolean : () => new BooleanSchema(),\n  /**\n   * Creates a string schema.\n   */\n  string: () => new StringSchema(),\n\n  /**\n   * Creates a number schema.\n   */\n  number: () => new NumberSchema(),\n\n  /**\n   * Creates an object schema with a defined shape.\n   * @param shape An object mapping keys to schemas.\n   */\n  object: <TShape extends ObjectShape>(shape: TShape) => new ObjectSchema(shape),\n\n  /**\n   * Creates an array schema with a defined element schema.\n   * @param elementSchema The schema for elements within the array.\n   */\n  array: <TElementSchema extends BaseSchema<any>>(elementSchema: TElementSchema) => new ArraySchema(elementSchema),\n\n  // Add more factory methods here (boolean, union, literal, etc.)\n};"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@nubase/core",
+  "version": "0.1.0",
+  "description": "Core schema and types for nubase",
+  "keywords": ["schema", "types", "validation", "zod"],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "files": [
+    "dist",
+    "schema"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "vitest": "^3.1.4"
+  },
+  "dependencies": {
+    "zod": "^3.25.20"
+  }
+}

package/schema/base-schema.ts

@@ -0,0 +1,46 @@
+// src/schema/BaseSchema.ts
+
+import { z } from 'zod'; // We'll need Zod later for toZod conversion
+
+// Define metadata types
+export interface SchemaMetadata<Output = any> {
+  label?: string;
+  description?: string;
+  defaultValue?: Output;
+}
+
+// Base schema class
+export abstract class BaseSchema<Output = any> {
+  /**
+   * Phantom property used for TypeScript type inference.
+   * Does not exist at runtime.
+   * @internal
+   */
+  readonly _outputType!: Output;
+
+  _meta: SchemaMetadata<Output> = {};
+
+  /**
+   * Replace the schema metadata with a new object.
+   * @param meta The new metadata object.
+   * @returns The schema instance for chaining.
+   */
+  meta(meta: SchemaMetadata<Output>): this {
+    this._meta = meta;
+    return this;
+  }
+
+  /**
+   * Parses and validates the input data against the schema.
+   * Should throw an error if validation fails.
+   * @param data The data to parse.
+   * @returns The parsed data (potentially transformed).
+   */
+  abstract parse(data: any): Output;
+
+  // We could also add a safeParse method like Zod if needed
+  // safeParse(data: any): { success: true; data: Output } | { success: false; error: SchemaError };
+}
+
+// Define a union type of all concrete schema types for easier handling
+export type NuSchema = BaseSchema<any>; // This will be refined later

package/schema/entity-schema.ts

@@ -0,0 +1,19 @@
+import { BaseSchema } from "./base-schema"
+
+export interface ResourceDescriptor {
+    search: ResourceOperationDescriptor
+    view: ResourceOperationDescriptor
+    edit: ResourceOperationDescriptor
+    create: ResourceOperationDescriptor
+    delete: ResourceOperationDescriptor
+}
+
+export type ResourceOperationDescriptor = {
+    // /r/contacts
+    resourceName: string,
+    endpoint: string
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE',
+    querySchema?: BaseSchema,
+    bodySchema?: BaseSchema,
+    responseSchema?: BaseSchema
+}

package/schema/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export { BaseSchema, type SchemaMetadata } from './base-schema';
+export * from './nu';

package/schema/nu.test.ts

@@ -0,0 +1,325 @@
+// src/tests/nu.test.ts
+
+import { describe, it, expect, expectTypeOf } from 'vitest';
+import { nu } from './nu';
+import { toZod } from './toZod';
+import { z } from 'zod';
+
+describe('nubase Schema Library (nu)', () => {
+
+  // --- Basic Schema Creation and Metadata ---
+  it('should create a string schema with metadata', () => {
+    const stringSchema = nu.string().meta({
+      label: 'Username',
+      description: 'The user\'s login name',
+    })
+    expect(stringSchema).toBeDefined();
+    expect(stringSchema._meta.label).toBe('Username');
+    expect(stringSchema._meta.description).toBe('The user\'s login name');
+  });
+
+  it('should create a number schema with metadata', () => {
+    const numberSchema = nu.number().meta({
+      label: 'Age',
+    });
+    expect(numberSchema).toBeDefined();
+    expect(numberSchema._meta.label).toBe('Age');
+  });
+
+  it('should create an object schema with nested schemas and metadata', () => {
+    const objectSchema = nu.object({
+      id: nu.number(),
+      name: nu.string().meta({
+        label: 'Full Name',
+      }),
+      address: nu.object({
+        street: nu.string(),
+        city: nu.string(),
+        zip: nu.string(),
+      }).meta({
+        label: 'Address',
+        description: 'User\'s mailing address',
+      }),
+    }).meta({
+      description: 'User Profile',
+    });
+
+    expect(objectSchema).toBeDefined();
+    expect(objectSchema._shape.id).toBeDefined();
+    expect(objectSchema._shape.name).toBeDefined();
+    expect(objectSchema._shape.name._meta.label).toBe('Full Name');
+    expect(objectSchema._meta.description).toBe('User Profile');
+  });
+
+  it('should create an array schema with an element schema', () => {
+    const arraySchema = nu.array(nu.string().meta({ label: 'Item' })).meta({ label: 'List of Items' });
+    expect(arraySchema).toBeDefined();
+    expect(arraySchema._element).toBeDefined();
+    expect(arraySchema._element._meta.label).toBe('Item');
+    expect(arraySchema._meta.label).toBe('List of Items');
+  });
+
+  // --- Parse/Validation Tests ---
+  it('should parse valid string data', () => {
+    const stringSchema = nu.string();
+    expect(stringSchema.parse('hello')).toBe('hello');
+  });
+
+  it('should throw error for invalid string data', () => {
+    const stringSchema = nu.string();
+    expect(() => stringSchema.parse(123)).toThrow('Expected string, received number');
+  });
+
+  it('should parse valid number data', () => {
+    const numberSchema = nu.number();
+    expect(numberSchema.parse(123)).toBe(123);
+    expect(numberSchema.parse(123.45)).toBe(123.45);
+  });
+
+  it('should throw error for invalid number data', () => {
+    const numberSchema = nu.number();
+    expect(() => numberSchema.parse('abc')).toThrow('Expected number, received string');
+    expect(() => numberSchema.parse(NaN)).toThrow('Expected number, received number'); // NaN is typeof number but not finite
+    expect(() => numberSchema.parse(Infinity)).toThrow('Expected number, received number');
+  });
+
+  it('should parse valid object data', () => {
+    const userSchema = nu.object({
+      id: nu.number(),
+      name: nu.string(),
+      isActive: nu.boolean().meta({ label: 'Active', defaultValue: true }), // Only supported keys
+    });
+     // Note: Literal/boolean schemas aren't implemented, using parse here as a placeholder for demo.
+     // A real implementation would have nu.boolean() and potentially nu.literal()
+
+    const validData = { id: 1, name: 'Alice', isActive: true };
+    expect(userSchema.parse(validData)).toEqual(validData);
+  });
+
+
+  it('should throw error for invalid object data (wrong type)', () => {
+    const userSchema = nu.object({ id: nu.number(), name: nu.string() });
+    expect(() => userSchema.parse(123)).toThrow('Expected object, received number');
+    expect(() => userSchema.parse(null)).toThrow('Expected object, received object'); // typeof null is 'object'
+  });
+
+  it('should throw error for invalid object data (invalid property)', () => {
+    const userSchema = nu.object({ id: nu.number(), name: nu.string() });
+    const invalidData = { id: 'one', name: 'Alice' };
+    expect(() => userSchema.parse(invalidData)).toThrow(/Object validation failed:\nProperty "id": Expected number, received string/);
+  });
+
+    // Note: Current ObjectSchema parse ignores extra keys. Add a test if you change that.
+    it('should ignore extra keys in object data by default', () => {
+        const userSchema = nu.object({ id: nu.number(), name: nu.string() });
+        const dataWithExtra = { id: 1, name: 'Alice', age: 30 };
+        const parsedData = userSchema.parse(dataWithExtra);
+        expect(parsedData).toEqual({ id: 1, name: 'Alice' }); // Extra 'age' is ignored
+    });
+
+
+  it('should parse valid array data', () => {
+    const stringArraySchema = nu.array(nu.string());
+    const validData = ['a', 'b', 'c'];
+    expect(stringArraySchema.parse(validData)).toEqual(validData);
+  });
+
+   it('should throw error for invalid array data (wrong type)', () => {
+        const stringArraySchema = nu.array(nu.string());
+        expect(() => stringArraySchema.parse('not an array')).toThrow('Expected array, received string');
+    });
+
+  it('should throw error for invalid array data (invalid element)', () => {
+    const stringArraySchema = nu.array(nu.string());
+    const invalidData = ['a', 123, 'c'];
+    expect(() => stringArraySchema.parse(invalidData)).toThrow(/Array validation failed:\nElement at index 1: Expected string, received number/);
+  });
+
+  // --- toZod Conversion Tests ---
+
+  it('should convert a string schema to a Zod string schema', () => {
+    const nuString = nu.string();
+    const zodString = toZod(nuString);
+    expect(zodString instanceof z.ZodString).toBe(true);
+    // Test Zod validation
+    expect(zodString.parse('test')).toBe('test');
+    expect(() => zodString.parse(123)).toThrow();
+  });
+
+  it('should convert a number schema to a Zod number schema', () => {
+    const nuNumber = nu.number();
+    const zodNumber = toZod(nuNumber);
+    expect(zodNumber instanceof z.ZodNumber).toBe(true);
+    // Test Zod validation
+    expect(zodNumber.parse(123)).toBe(123);
+    expect(() => zodNumber.parse('test')).toThrow();
+  });
+
+  it('should convert an object schema to a Zod object schema', () => {
+    const nuObject = nu.object({
+      name: nu.string(),
+      age: nu.number().meta({ label: 'User Age' })
+    });
+
+    const zodObject = toZod(nuObject);
+
+    expect(zodObject instanceof z.ZodObject).toBe(true);
+
+    // Check the structure of the converted Zod schema
+    expect(zodObject.shape.name instanceof z.ZodString).toBe(true);
+    expect(zodObject.shape.age instanceof z.ZodNumber).toBe(true);
+
+    // Test Zod validation
+    const validData = { name: 'Bob', age: 42 };
+    expect(zodObject.parse(validData)).toEqual(validData);
+    expect(() => zodObject.parse({ name: 'Bob', age: 'old' })).toThrow();
+  });
+
+  it('should convert an array schema to a Zod array schema', () => {
+    const nuArray = nu.array(nu.number());
+    const zodArray = toZod(nuArray);
+    expect(zodArray instanceof z.ZodArray).toBe(true);
+    expect(zodArray.element instanceof z.ZodNumber).toBe(true);
+
+    // Test Zod validation
+    const validData = [1, 2, 3];
+    expect(zodArray.parse(validData)).toEqual(validData);
+    expect(() => zodArray.parse([1, 'two', 3])).toThrow();
+  });
+
+  it('should handle nested structures in toZod conversion', () => {
+      const nestedNuSchema = nu.object({
+          user: nu.object({
+              name: nu.string(),
+              address: nu.object({
+                  street: nu.string(),
+                  zip: nu.string()
+              })
+          }),
+          tags: nu.array(nu.string())
+      });
+
+      const nestedZodSchema = toZod(nestedNuSchema);
+
+      // Check types in the converted Zod schema structure
+      expect(nestedZodSchema instanceof z.ZodObject).toBe(true);
+      expect(nestedZodSchema.shape.user instanceof z.ZodObject).toBe(true);
+      expect((nestedZodSchema.shape.user as z.ZodObject<any>).shape.name instanceof z.ZodString).toBe(true);
+      expect((nestedZodSchema.shape.user as z.ZodObject<any>).shape.address instanceof z.ZodObject).toBe(true);
+      expect(((nestedZodSchema.shape.user as z.ZodObject<any>).shape.address as z.ZodObject<any>).shape.street instanceof z.ZodString).toBe(true);
+      expect(nestedZodSchema.shape.tags instanceof z.ZodArray).toBe(true);
+      expect((nestedZodSchema.shape.tags as z.ZodArray<any>).element instanceof z.ZodString).toBe(true);
+
+
+      // Test Zod validation with nested structure
+      const validData = {
+          user: {
+              name: 'Charlie',
+              address: { street: 'Main St', zip: '12345' }
+          },
+          tags: ['a', 'b']
+      };
+      expect(nestedZodSchema.parse(validData)).toEqual(validData);
+
+      const invalidData = {
+           user: {
+              name: 'Charlie',
+              address: { street: 123, zip: '12345' } // invalid street type
+          },
+          tags: ['a', 'b']
+      };
+      expect(() => nestedZodSchema.parse(invalidData)).toThrow();
+  });
+
+
+  // --- TypeScript Type Inference Tests ---
+
+  it('should infer correct type for primitive schemas', () => {
+    const s = nu.string();
+    const n = nu.number();
+
+    // Check inferred output type
+    expectTypeOf(s).toHaveProperty('_outputType').toBeString();
+    expectTypeOf(n).toHaveProperty('_outputType').toBeNumber();
+  });
+
+  it('should infer correct type for object schema', () => {
+    const userSchema = nu.object({
+      id: nu.number().meta({ label: 'User ID' }),
+      name: nu.string(),
+      settings: nu.object({
+          theme: nu.string(),
+          darkMode: nu.boolean().meta({ label: 'Switch' }) // Only supported keys
+      })
+    });
+
+    // Check inferred output type structure
+    expectTypeOf(userSchema).toHaveProperty('_outputType').toMatchTypeOf<{
+        id: number;
+        name: string;
+        settings: {
+            theme: string;
+            darkMode: any; // Placeholder output type from .parse(true)
+        }
+    }>();
+
+    // Test that assigning parsed data is type-safe
+    const userData = { id: 1, name: 'Test', settings: { theme: 'dark', darkMode: false } };
+    const parsedUser = userSchema.parse(userData);
+    expectTypeOf(parsedUser).toMatchTypeOf<{ id: number; name: string; settings: { theme: string; darkMode: any; } }>();
+
+    // This would be a TS error if types mismatched:
+    // const badParsedUser: string = userSchema.parse(userData); // TS error expected
+  });
+
+  it('should infer correct type for array schema', () => {
+    const numberArraySchema = nu.array(nu.number()); // Removed unsupported minValue metadata
+    const stringArraySchema = nu.array(nu.string().meta({ label: 'Entry' }));
+    const arrayOfObjectsSchema = nu.array(nu.object({ id: nu.number(), value: nu.string() }));
+
+
+    // Check inferred output types
+    expectTypeOf(numberArraySchema).toHaveProperty('_outputType').toBeArray();
+    expectTypeOf(stringArraySchema).toHaveProperty('_outputType').toBeArray();
+    expectTypeOf(arrayOfObjectsSchema).toHaveProperty('_outputType').toBeArray();
+
+
+    // Test that assigning parsed data is type-safe
+    const numberArrayData = [1, 2, 3];
+    const parsedNumberArray = numberArraySchema.parse(numberArrayData);
+    expectTypeOf(parsedNumberArray).toBeArray();
+     // This would be a TS error:
+    // const badParsedNumberArray: string[] = parsedNumberArray; // TS error expected
+  });
+
+
+    it('should infer correct Zod schema type after toZod conversion', () => {
+        const nuString = nu.string().meta({ label: 'ID' });
+        const zodString = toZod(nuString);
+        expectTypeOf(zodString).toMatchTypeOf<z.ZodString>(); // Should be a ZodString
+        expectTypeOf(zodString._output).toBeString(); // Should infer string output
+
+
+        const nuObject = nu.object({
+            name: nu.string(),
+            age: nu.number()
+        });
+        const zodObject = toZod(nuObject);
+        expectTypeOf(zodObject).toMatchTypeOf<z.ZodObject<any>>(); // Should be a ZodObject
+         expectTypeOf(zodObject._output).toMatchTypeOf<{ name: string, age: number }>(); // Should infer the object type
+
+
+        const nuArray = nu.array(nu.string());
+        const zodArray = toZod(nuArray);
+        expectTypeOf(zodArray).toMatchTypeOf<z.ZodArray<z.ZodString>>(); // Should be ZodArray of ZodString
+
+        const nuNested = nu.object({
+            items: nu.array(nu.object({
+                id: nu.number()
+            }))
+        });
+         const zodNested = toZod(nuNested);
+         expectTypeOf(zodNested._output).toMatchTypeOf<{ items: Array<{ id: number }> }>(); // Should infer nested type
+    });
+
+});

package/schema/nu.ts

@@ -0,0 +1,36 @@
+// src/nu.ts
+
+import { BaseSchema } from "./base-schema";
+import { StringSchema, NumberSchema, ObjectShape, ObjectSchema, ArraySchema, BooleanSchema } from "./types";
+
+
+/**
+ * The main nubase schema instance.
+ * Provides factory methods to create different schema types.
+ */
+export const nu = {
+  boolean : () => new BooleanSchema(),
+  /**
+   * Creates a string schema.
+   */
+  string: () => new StringSchema(),
+
+  /**
+   * Creates a number schema.
+   */
+  number: () => new NumberSchema(),
+
+  /**
+   * Creates an object schema with a defined shape.
+   * @param shape An object mapping keys to schemas.
+   */
+  object: <TShape extends ObjectShape>(shape: TShape) => new ObjectSchema(shape),
+
+  /**
+   * Creates an array schema with a defined element schema.
+   * @param elementSchema The schema for elements within the array.
+   */
+  array: <TElementSchema extends BaseSchema<any>>(elementSchema: TElementSchema) => new ArraySchema(elementSchema),
+
+  // Add more factory methods here (boolean, union, literal, etc.)
+};

package/schema/toZod.ts

@@ -0,0 +1,74 @@
+// src/converters/toZod.ts
+
+import { z } from 'zod';
+import {
+  StringSchema,
+  NumberSchema,
+  ObjectSchema,
+  ArraySchema,
+  NuSchema, // The union type of all nu schemas
+  ObjectOutput // Type utility to get object output type
+} from '../schema/types';
+
+
+/**
+ * Infers the Zod schema type corresponding to a given NuSchema type.
+ * This is a conditional type that maps NuSchema types to their Zod equivalents
+ * and preserves the output type.
+ */
+export type NuSchemaToZodSchema<S extends NuSchema> =
+  S extends StringSchema ? z.ZodString :
+  S extends NumberSchema ? z.ZodNumber :
+  S extends ObjectSchema<infer TShape> ? z.ZodObject<{
+      [K in keyof TShape]: NuSchemaToZodSchema<TShape[K]>;
+    }, any, z.ZodTypeAny, ObjectOutput<TShape>> : // Recursive mapping for object shape
+  S extends ArraySchema<infer TElementSchema> ? z.ZodArray<NuSchemaToZodSchema<TElementSchema>> : // Recursive mapping for array element
+  z.ZodSchema<any>; // Fallback for unknown types
+
+
+/**
+ * Converts a nubase schema to a Zod schema.
+ * Preserves the TypeScript output type.
+ * Metadata (label, description etc.) is NOT translated to Zod schema properties
+ * as Zod doesn't have direct equivalents in its core schema structure.
+ * It only translates the validation structure and output type.
+ *
+ * @param schema The nubase schema to convert.
+ * @returns The equivalent Zod schema.
+ */
+export function toZod<S extends NuSchema>(schema: S): NuSchemaToZodSchema<S> {
+  if (schema instanceof StringSchema) {
+    // Add Zod string validations based on schema._meta or specific properties if they exist
+    // e.g., if (schema._meta.minLength) zodSchema = zodSchema.min(schema._meta.minLength);
+    // For now, just the base type:
+    return z.string() as NuSchemaToZodSchema<S>;
+  }
+
+  if (schema instanceof NumberSchema) {
+    // Add Zod number validations similarly
+    return z.number() as NuSchemaToZodSchema<S>;
+  }
+
+  if (schema instanceof ObjectSchema) {
+    const zodShape: Record<string, z.ZodTypeAny> = {};
+    // Recursively convert each schema in the shape
+    for (const key in schema._shape) {
+      if (Object.prototype.hasOwnProperty.call(schema._shape, key)) {
+        zodShape[key] = toZod(schema._shape[key]); // Recursive call
+      }
+    }
+    // Zod object constructor needs the shape object
+    return z.object(zodShape) as NuSchemaToZodSchema<S>;
+  }
+
+  if (schema instanceof ArraySchema) {
+     // Recursively convert the element schema
+    const zodElementSchema = toZod(schema._element);
+    // Zod array constructor needs the element schema
+    return z.array(zodElementSchema) as NuSchemaToZodSchema<S>;
+  }
+
+  // Handle other schema types here...
+  // For now, throw an error for unsupported types
+  throw new Error(`Unsupported schema type for Zod conversion: ${schema.constructor.name}`);
+}

package/schema/types.ts

@@ -0,0 +1,149 @@
+// src/schema/types.ts
+
+import { BaseSchema } from './base-schema';
+
+// --- Primitive Schemas ---
+
+export class BooleanSchema extends BaseSchema<boolean> {
+  parse(data: any): boolean {
+    if (typeof data !== 'boolean') {
+      throw new Error(`Expected boolean, received ${typeof data}`);
+    }
+    return data;
+  }
+}
+
+export class StringSchema extends BaseSchema<string> {
+  parse(data: any): string {
+    if (typeof data !== 'string') {
+      throw new Error(`Expected string, received ${typeof data}`);
+    }
+    return data;
+  }
+  // Add string-specific validation methods here (e.g., minLength, pattern)
+}
+
+export class NumberSchema extends BaseSchema<number> {
+  parse(data: any): number {
+    if (typeof data !== 'number' || !Number.isFinite(data)) {
+      throw new Error(`Expected number, received ${typeof data}`);
+    }
+    return data;
+  }
+  // Add number-specific validation methods here (e.g., min, max)
+}
+
+// Add more primitives like BooleanSchema, NullableSchema, OptionalSchema etc.
+
+// --- Complex Schemas ---
+
+/**
+ * Type representing the shape of an object schema (key to schema mapping).
+ */
+export type ObjectShape = {
+  [key: string]: BaseSchema<any>;
+};
+
+/**
+ * Infers the TypeScript output type from an ObjectShape.
+ * Use mapped types to get the output type of each property schema.
+ */
+export type ObjectOutput<TShape extends ObjectShape> = {
+  [K in keyof TShape]: TShape[K]['_outputType'];
+};
+
+export class ObjectSchema<TShape extends ObjectShape> extends BaseSchema<ObjectOutput<TShape>> {
+  _shape: TShape;
+
+  constructor(shape: TShape) {
+    super();
+    this._shape = shape;
+  }
+
+  parse(data: any): ObjectOutput<TShape> {
+    if (typeof data !== 'object' || data === null) {
+      throw new Error(`Expected object, received ${typeof data}`);
+    }
+
+    const result: any = {};
+    const errors: string[] = [];
+
+    // Validate defined properties
+    for (const key in this._shape) {
+      if (Object.prototype.hasOwnProperty.call(this._shape, key)) {
+        const schema = this._shape[key];
+        const value = (data as any)[key]; // Get value from input data
+        try {
+          if (schema) {
+            result[key] = schema.parse(value); // Recursively parse property
+          }
+        } catch (e: any) {
+          errors.push(`Property "${key}": ${e.message}`);
+        }
+      }
+    }
+
+    // Basic handling for extra keys (can be made configurable)
+    for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key) && !Object.prototype.hasOwnProperty.call(this._shape, key)) {
+            // For now, ignore extra keys. Could throw an error or strip them.
+            // errors.push(`Unknown property "${key}"`);
+            // console.warn(`Warning: Unknown property "${key}" in object data.`);
+        }
+    }
+
+
+    if (errors.length > 0) {
+      throw new Error(`Object validation failed:\n${errors.join('\n')}`);
+    }
+
+    return result as ObjectOutput<TShape>;
+  }
+}
+
+/**
+ * Infers the TypeScript output type from an element schema for an array.
+ */
+export type ArrayOutput<TElementSchema extends BaseSchema<any>> = Array<TElementSchema['_outputType']>;
+
+
+export class ArraySchema<TElementSchema extends BaseSchema<any>> extends BaseSchema<ArrayOutput<TElementSchema>> {
+  _element: TElementSchema;
+
+  constructor(elementSchema: TElementSchema) {
+    super();
+    this._element = elementSchema;
+  }
+
+  parse(data: any): ArrayOutput<TElementSchema> {
+    if (!Array.isArray(data)) {
+      throw new Error(`Expected array, received ${typeof data}`);
+    }
+
+    const result: any[] = [];
+    const errors: string[] = [];
+
+    for (let i = 0; i < data.length; i++) {
+      try {
+        result[i] = this._element.parse(data[i]); // Recursively parse each element
+      } catch (e: any) {
+        errors.push(`Element at index ${i}: ${e.message}`);
+      }
+    }
+
+    if (errors.length > 0) {
+        throw new Error(`Array validation failed:\n${errors.join('\n')}`);
+    }
+
+    return result as ArrayOutput<TElementSchema>;
+  }
+}
+
+// Refine NuSchema union after defining concrete types
+export type NuSchema =
+  | BooleanSchema
+  | StringSchema
+  | NumberSchema
+  // Add others like BooleanSchema
+  | ObjectSchema<any>
+  | ArraySchema<any>;