@nubase/core 0.1.0 → 0.1.4

package/dist/index.mjs

@@ -1,4 +1,269 @@
-// schema/base-schema.ts
+// ../frontend/src/http/http-client.ts
+import axios, { AxiosError } from "axios";
+
+// ../frontend/src/utils/network-errors.ts
+var NetworkError = class extends Error {
+  endpoint;
+  method;
+  timestamp;
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.endpoint = options.endpoint;
+    this.method = options.method;
+    this.timestamp = /* @__PURE__ */ new Date();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var ClientNetworkError = class _ClientNetworkError extends NetworkError {
+  // Custom inspect method for Node.js and some browser consoles
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+  // For browsers that support console formatting
+  get [Symbol.toStringTag]() {
+    return JSON.stringify(this.toJSON(), null, 2);
+  }
+  phase;
+  parseErrors;
+  originalError;
+  zodError;
+  constructor(message, options) {
+    super(message, options);
+    this.phase = options.phase;
+    this.parseErrors = options.parseErrors;
+    this.originalError = options.originalError;
+    this.zodError = options.zodError;
+  }
+  toString() {
+    const details = [];
+    details.push(`${this.name}: ${this.message}`);
+    details.push(`  Endpoint: ${this.method} ${this.endpoint}`);
+    details.push(`  Phase: ${this.phase}`);
+    details.push(`  Timestamp: ${this.timestamp.toISOString()}`);
+    if (this.zodError) {
+      details.push(`  Zod Error: ${this.zodError.toString()}`);
+      if (this.zodError.issues.length > 0) {
+        details.push("  Validation Issues:");
+        this.zodError.issues.forEach((issue, index) => {
+          const path = issue.path.length > 0 ? issue.path.join(".") : "root";
+          details.push(
+            `    ${index + 1}. Path: ${path}, Message: ${issue.message}, Code: ${issue.code}`
+          );
+        });
+      }
+    }
+    if (this.parseErrors && this.parseErrors.length > 0) {
+      details.push("  Parse Errors:");
+      this.parseErrors.forEach((error, index) => {
+        details.push(
+          `    ${index + 1}. Path: ${error.path}, Message: ${error.message}, Code: ${error.code}`
+        );
+        if (error.expected) details.push(`       Expected: ${error.expected}`);
+        if (error.received) details.push(`       Received: ${error.received}`);
+      });
+    }
+    if (this.originalError) {
+      const errorStr = this.originalError instanceof Error ? this.originalError.toString() : String(this.originalError);
+      details.push(`  Original Error: ${errorStr}`);
+    }
+    return details.join("\n");
+  }
+  toJSON() {
+    const result = {
+      name: this.name,
+      message: this.message,
+      endpoint: this.endpoint,
+      method: this.method,
+      phase: this.phase,
+      timestamp: this.timestamp.toISOString()
+    };
+    if (this.zodError) {
+      result.zodError = this.zodError.issues;
+    }
+    if (this.parseErrors && this.parseErrors.length > 0) {
+      result.parseErrors = this.parseErrors;
+    }
+    if (this.originalError) {
+      result.originalError = this.originalError instanceof Error ? {
+        name: this.originalError.name,
+        message: this.originalError.message
+      } : this.originalError;
+    }
+    return result;
+  }
+  /**
+   * Creates a ClientNetworkError for network failures (no response from server)
+   */
+  static fromNetworkFailure(error, options) {
+    const message = error instanceof Error ? `Network request failed for ${options.method} ${options.endpoint}: ${error.message}` : `Network request failed for ${options.method} ${options.endpoint}`;
+    return new _ClientNetworkError(message, {
+      ...options,
+      phase: "network-failure",
+      originalError: error
+    });
+  }
+};
+var ServerNetworkError = class _ServerNetworkError extends NetworkError {
+  // Custom inspect method for Node.js and some browser consoles
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+  // For browsers that support console formatting
+  get [Symbol.toStringTag]() {
+    return JSON.stringify(this.toJSON(), null, 2);
+  }
+  statusCode;
+  responseText;
+  responseData;
+  constructor(message, options) {
+    super(message, options);
+    this.statusCode = options.statusCode;
+    this.responseText = options.responseText;
+    this.responseData = options.responseData;
+  }
+  toString() {
+    const details = [];
+    details.push(`${this.name}: ${this.message}`);
+    details.push(`  Endpoint: ${this.method} ${this.endpoint}`);
+    details.push(`  Status Code: ${this.statusCode}`);
+    details.push(`  Timestamp: ${this.timestamp.toISOString()}`);
+    if (this.responseText) {
+      details.push(`  Response Text: ${this.responseText}`);
+    }
+    if (this.responseData) {
+      try {
+        const dataStr = typeof this.responseData === "string" ? this.responseData : JSON.stringify(this.responseData, null, 2);
+        details.push(`  Response Data: ${dataStr}`);
+      } catch {
+        details.push(`  Response Data: ${String(this.responseData)}`);
+      }
+    }
+    return details.join("\n");
+  }
+  toJSON() {
+    const result = {
+      name: this.name,
+      message: this.message,
+      endpoint: this.endpoint,
+      method: this.method,
+      statusCode: this.statusCode,
+      timestamp: this.timestamp.toISOString()
+    };
+    if (this.responseText) {
+      result.responseText = this.responseText;
+    }
+    if (this.responseData) {
+      result.responseData = this.responseData;
+    }
+    return result;
+  }
+  /**
+   * Creates a ServerNetworkError from an HTTP response
+   */
+  static fromResponse(response, responseText, responseData) {
+    const message = `Server error ${response.status} for ${response.url}: ${response.statusText}`;
+    return new _ServerNetworkError(message, {
+      endpoint: response.url,
+      method: "GET",
+      // Will be overridden by caller with actual method
+      statusCode: response.status,
+      responseText,
+      responseData
+    });
+  }
+  /**
+   * Checks if this is a specific type of server error
+   */
+  isNotFound() {
+    return this.statusCode === 404;
+  }
+  isUnauthorized() {
+    return this.statusCode === 401;
+  }
+  isForbidden() {
+    return this.statusCode === 403;
+  }
+  isServerError() {
+    return this.statusCode >= 500;
+  }
+  isClientError() {
+    return this.statusCode >= 400 && this.statusCode < 500;
+  }
+};
+
+// ../frontend/src/http/http-client.ts
+var HttpClient = class {
+  baseUrl;
+  constructor({ baseUrl = "" }) {
+    this.baseUrl = baseUrl;
+  }
+  async request(url, method, data, config = {}) {
+    const fullUrl = this.baseUrl ? `${this.baseUrl}${url}` : url;
+    try {
+      const response = await axios({
+        url: fullUrl,
+        method,
+        data,
+        headers: config.headers,
+        timeout: config.timeout,
+        params: config.params,
+        withCredentials: true
+        // Required for sending cookies in cross-origin requests
+      });
+      return {
+        status: response.status,
+        data: response.data
+      };
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        if (error.response) {
+          throw new ServerNetworkError(
+            `Server error ${error.response.status} for ${method} ${url}: ${error.response.statusText}`,
+            {
+              endpoint: url,
+              method,
+              statusCode: error.response.status,
+              responseText: error.response.statusText,
+              responseData: error.response.data
+            }
+          );
+        }
+        if (error.request) {
+          throw ClientNetworkError.fromNetworkFailure(error, {
+            endpoint: url,
+            method
+          });
+        }
+        throw ClientNetworkError.fromNetworkFailure(error, {
+          endpoint: url,
+          method
+        });
+      }
+      throw error;
+    }
+  }
+  async get(url, config) {
+    return this.request(url, "GET", void 0, config);
+  }
+  async post(url, data, config) {
+    return this.request(url, "POST", data, config);
+  }
+  async put(url, data, config) {
+    return this.request(url, "PUT", data, config);
+  }
+  async patch(url, data, config) {
+    return this.request(url, "PATCH", data, config);
+  }
+  async delete(url, data, config) {
+    return this.request(url, "DELETE", data, config);
+  }
+};
+
+// src/schema/schema.ts
+import { z } from "zod";
 var BaseSchema = class {
   /**
    * Phantom property used for TypeScript type inference.
@@ -12,105 +277,457 @@ var BaseSchema = class {
    * @param meta The new metadata object.
    * @returns The schema instance for chaining.
    */
-  meta(meta) {
+  withMeta(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 };
+  /**
+   * Add metadata with validation functions to the schema.
+   * @param meta The metadata object with validation functions.
+   * @returns The schema instance for chaining.
+   */
+  withMetadata(meta) {
+    this._meta = { ...this._meta, ...meta };
+    return this;
+  }
+  /**
+   * Makes this schema optional, allowing undefined values.
+   * @returns An OptionalSchema wrapping this schema.
+   */
+  optional() {
+    return new OptionalSchema(this);
+  }
 };
-
-// schema/types.ts
 var BooleanSchema = class extends BaseSchema {
-  parse(data) {
-    if (typeof data !== "boolean") {
-      throw new Error(`Expected boolean, received ${typeof data}`);
-    }
-    return data;
+  type = "boolean";
+  toZod() {
+    return z.boolean();
   }
 };
 var StringSchema = class extends BaseSchema {
-  parse(data) {
-    if (typeof data !== "string") {
-      throw new Error(`Expected string, received ${typeof data}`);
-    }
-    return data;
-  }
+  type = "string";
   // Add string-specific validation methods here (e.g., minLength, pattern)
+  toZod() {
+    return z.string();
+  }
 };
 var NumberSchema = class extends BaseSchema {
-  parse(data) {
-    if (typeof data !== "number" || !Number.isFinite(data)) {
-      throw new Error(`Expected number, received ${typeof data}`);
-    }
-    return data;
-  }
+  type = "number";
   // Add number-specific validation methods here (e.g., min, max)
+  toZod() {
+    return z.number();
+  }
+};
+var OptionalSchema = class extends BaseSchema {
+  type = "optional";
+  _wrapped;
+  constructor(wrapped) {
+    super();
+    this._wrapped = wrapped;
+  }
+  /**
+   * Get the underlying wrapped schema.
+   * @returns The wrapped schema.
+   */
+  unwrap() {
+    return this._wrapped;
+  }
+  toZod() {
+    return this._wrapped.toZod().nullable().optional();
+  }
 };
-var ObjectSchema = class extends BaseSchema {
+var ObjectSchema = class _ObjectSchema extends BaseSchema {
+  type = "object";
   _shape;
-  constructor(shape) {
+  _computedMeta = {};
+  _layouts = {};
+  _idField = "id";
+  _catchall = null;
+  constructor(shape, catchall) {
     super();
     this._shape = shape;
+    if (catchall) {
+      this._catchall = catchall;
+    }
+  }
+  /**
+   * Allow additional properties beyond the defined shape, validated against the provided schema.
+   * Similar to Zod's .catchall() method.
+   *
+   * @example
+   * const chartDataSchema = nu.object({ category: nu.string() }).catchall(nu.number());
+   * // Validates: { category: "Jan", desktop: 186, mobile: 80 }
+   *
+   * @param schema The schema to validate additional properties against.
+   * @returns A new ObjectSchema that allows additional properties.
+   */
+  catchall(schema) {
+    const newSchema = new _ObjectSchema(
+      this._shape,
+      schema
+    );
+    newSchema._meta = { ...this._meta };
+    newSchema._computedMeta = { ...this._computedMeta };
+    newSchema._layouts = { ...this._layouts };
+    newSchema._idField = this._idField;
+    return newSchema;
+  }
+  /**
+   * Add computed metadata to the object schema.
+   * @param computedMeta Object mapping property keys to computed metadata functions.
+   * @returns The schema instance for chaining.
+   */
+  withComputed(computedMeta) {
+    this._computedMeta = computedMeta;
+    return this;
+  }
+  /**
+   * Add layouts to the object schema.
+   * @param layouts Object mapping layout names to layout configurations.
+   * @returns The schema instance for chaining.
+   * @deprecated Use withFormLayouts or withTableLayouts instead
+   */
+  withLayouts(layouts) {
+    this._layouts = layouts;
+    return this;
+  }
+  /**
+   * Add form layouts to the object schema.
+   * @param layouts Object mapping layout names to form layout configurations.
+   * @returns The schema instance for chaining.
+   */
+  withFormLayouts(layouts) {
+    this._layouts = { ...this._layouts, ...layouts };
+    return this;
+  }
+  /**
+   * Add table layouts to the object schema.
+   * @param layouts Object mapping layout names to table layout configurations with fields and optional linkFields.
+   * @returns The schema instance for chaining.
+   */
+  withTableLayouts(layouts) {
+    const tableLayouts = {};
+    for (const [name, tableConfig] of Object.entries(layouts)) {
+      tableLayouts[name] = {
+        type: "table",
+        groups: [
+          {
+            fields: tableConfig.fields
+          }
+        ],
+        className: tableConfig.className,
+        config: tableConfig.config,
+        metadata: tableConfig.metadata
+      };
+    }
+    this._layouts = { ...this._layouts, ...tableLayouts };
+    return this;
   }
-  parse(data) {
-    if (typeof data !== "object" || data === null) {
-      throw new Error(`Expected object, received ${typeof data}`);
+  /**
+   * Specify which field serves as the unique identifier for this object schema.
+   * This is used by resource operations to determine how to identify specific records.
+   * @param idField The field name or a selector function that returns the ID field.
+   * @returns The schema instance for chaining.
+   */
+  withId(idField) {
+    if (typeof idField === "function") {
+      throw new Error(
+        "Function form of withId is not yet supported. Please pass the field name directly."
+      );
+    }
+    this._idField = idField;
+    return this;
+  }
+  /**
+   * Get the ID field name for this object schema.
+   * @returns The field name that serves as the unique identifier.
+   */
+  getIdField() {
+    return this._idField;
+  }
+  /**
+   * Get a specific layout by name.
+   * @param layoutName The name of the layout to retrieve.
+   * @returns The layout configuration or undefined if not found.
+   */
+  getLayout(layoutName) {
+    return this._layouts[layoutName];
+  }
+  /**
+   * Get all available layout names.
+   * @returns Array of layout names.
+   */
+  getLayoutNames() {
+    return Object.keys(this._layouts);
+  }
+  /**
+   * Check if a layout exists.
+   * @param layoutName The name of the layout to check.
+   * @returns True if the layout exists, false otherwise.
+   */
+  hasLayout(layoutName) {
+    return layoutName in this._layouts;
+  }
+  /**
+   * Get the computed metadata for a specific property.
+   * @param key The property key.
+   * @param data The parsed object data to pass to computed functions.
+   * @returns Promise resolving to the computed metadata.
+   */
+  async getComputedMeta(key, data) {
+    const computedMeta = this._computedMeta[key];
+    if (!computedMeta) {
+      return {};
     }
     const result = {};
-    const errors = [];
+    if (computedMeta.label) {
+      result.label = await computedMeta.label(data);
+    }
+    if (computedMeta.description) {
+      result.description = await computedMeta.description(data);
+    }
+    if (computedMeta.defaultValue) {
+      result.defaultValue = await computedMeta.defaultValue(data);
+    }
+    return result;
+  }
+  /**
+   * Get all computed metadata for all properties.
+   * @param data The parsed object data to pass to computed functions.
+   * @returns Promise resolving to a map of property keys to computed metadata.
+   */
+  async getAllComputedMeta(data) {
+    const result = {};
     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);
+      result[key] = await this.getComputedMeta(key, data);
+    }
+    return result;
+  }
+  /**
+   * Get merged metadata (static + computed) for all properties.
+   * @param data The current form data to pass to computed functions.
+   * @returns Promise resolving to a map of property keys to merged metadata.
+   */
+  async getAllMergedMeta(data) {
+    const result = {};
+    for (const key in this._shape) {
+      if (Object.hasOwn(this._shape, key)) {
+        let schema = this._shape[key];
+        if (schema) {
+          if (schema instanceof OptionalSchema) {
+            schema = schema._wrapped;
+          }
+          result[key] = { ...schema?._meta || {} };
+        }
+      }
+    }
+    if (Object.keys(this._computedMeta).length > 0) {
+      try {
+        const completeData = {};
+        for (const key in this._shape) {
+          if (Object.hasOwn(this._shape, key)) {
+            const schema = this._shape[key];
+            if (schema) {
+              const actualSchema = schema instanceof OptionalSchema ? schema._wrapped : schema;
+              if (data[key] !== void 0) {
+                completeData[key] = data[key];
+              } else if (actualSchema._meta.defaultValue !== void 0) {
+                completeData[key] = actualSchema._meta.defaultValue;
+              } else {
+                if (actualSchema instanceof StringSchema) {
+                  completeData[key] = "";
+                } else if (actualSchema instanceof NumberSchema) {
+                  completeData[key] = 0;
+                } else if (actualSchema instanceof BooleanSchema) {
+                  completeData[key] = false;
+                } else {
+                  completeData[key] = null;
+                }
+              }
+            }
+          }
+        }
+        const computedMeta = await this.getAllComputedMeta(
+          completeData
+        );
+        for (const key in computedMeta) {
+          if (computedMeta[key]) {
+            result[key] = {
+              ...result[key],
+              ...computedMeta[key]
+            };
           }
-        } catch (e) {
-          errors.push(`Property "${key}": ${e.message}`);
         }
+      } catch (error) {
+        console.warn("Failed to compute metadata:", error);
       }
     }
-    for (const key in data) {
-      if (Object.prototype.hasOwnProperty.call(data, key) && !Object.prototype.hasOwnProperty.call(this._shape, key)) {
+    return result;
+  }
+  /**
+   * Create a new ObjectSchema with certain properties omitted.
+   * @param keys The property keys to omit from the schema.
+   * @returns A new ObjectSchema without the specified properties.
+   */
+  omit(...keys) {
+    const newShape = {};
+    const keysToOmit = new Set(keys);
+    for (const key in this._shape) {
+      if (Object.hasOwn(this._shape, key) && !keysToOmit.has(key)) {
+        newShape[key] = this._shape[key];
+      }
+    }
+    const newSchema = new _ObjectSchema(newShape);
+    newSchema._meta = { ...this._meta };
+    const newComputedMeta = {};
+    for (const key in this._computedMeta) {
+      if (!keysToOmit.has(key)) {
+        newComputedMeta[key] = this._computedMeta[key];
       }
     }
-    if (errors.length > 0) {
-      throw new Error(`Object validation failed:
-${errors.join("\n")}`);
+    newSchema._computedMeta = newComputedMeta;
+    const newLayouts = {};
+    for (const layoutName in this._layouts) {
+      const originalLayout = this._layouts[layoutName];
+      if (originalLayout) {
+        const newGroups = originalLayout.groups.map((group) => ({
+          ...group,
+          fields: group.fields.filter(
+            (field) => !keysToOmit.has(field.name)
+          )
+        }));
+        newLayouts[layoutName] = {
+          ...originalLayout,
+          groups: newGroups
+        };
+      }
     }
-    return result;
+    newSchema._layouts = newLayouts;
+    return newSchema;
+  }
+  /**
+   * Create a new ObjectSchema with additional or modified properties.
+   * @param shape The new properties to add or existing properties to modify.
+   * @returns A new ObjectSchema with the extended shape.
+   */
+  extend(shape) {
+    const newShape = { ...this._shape, ...shape };
+    const newSchema = new _ObjectSchema(newShape);
+    newSchema._meta = { ...this._meta };
+    newSchema._computedMeta = { ...this._computedMeta };
+    newSchema._layouts = { ...this._layouts };
+    return newSchema;
+  }
+  /**
+   * Create a new ObjectSchema where all top-level properties become optional.
+   * This wraps each field in an OptionalSchema, similar to how Zod handles partial.
+   * @returns A new ObjectSchema where all properties are optional.
+   */
+  partial() {
+    const partialShape = {};
+    for (const key in this._shape) {
+      if (Object.hasOwn(this._shape, key)) {
+        const fieldSchema = this._shape[key];
+        if (fieldSchema) {
+          if (fieldSchema instanceof OptionalSchema) {
+            partialShape[key] = fieldSchema;
+          } else {
+            partialShape[key] = fieldSchema.optional();
+          }
+        }
+      }
+    }
+    const partialSchema = new _ObjectSchema(partialShape);
+    partialSchema._meta = { ...this._meta };
+    partialSchema._computedMeta = { ...this._computedMeta };
+    partialSchema._layouts = { ...this._layouts };
+    return partialSchema;
+  }
+  toZod() {
+    const zodShape = {};
+    for (const key in this._shape) {
+      if (Object.hasOwn(this._shape, key) && this._shape[key]) {
+        const fieldSchema = this._shape[key];
+        zodShape[key] = fieldSchema.toZod();
+      }
+    }
+    const baseZod = z.object(zodShape);
+    if (this._catchall) {
+      return baseZod.catchall(this._catchall.toZod());
+    }
+    return baseZod;
+  }
+  /**
+   * Returns a Zod schema with URL coercion enabled.
+   * This automatically converts string values from URL parameters to the expected types:
+   * - "37" → 37 (number)
+   * - "true" → true (boolean)
+   * - "hello" → "hello" (string, unchanged)
+   *
+   * Use this when parsing URL search params that arrive as strings but need to be typed.
+   *
+   * @returns A Zod schema with coercion for URL parameter parsing
+   */
+  toZodWithCoercion() {
+    const zodShape = {};
+    for (const key in this._shape) {
+      if (Object.hasOwn(this._shape, key) && this._shape[key]) {
+        const fieldSchema = this._shape[key];
+        const baseZodSchema = fieldSchema.toZod();
+        const wrappedType = fieldSchema.type === "optional" ? fieldSchema._wrapped.type : null;
+        if (fieldSchema.type === "number" || wrappedType === "number") {
+          const coercedSchema = z.coerce.number();
+          if (fieldSchema.type === "optional") {
+            zodShape[key] = coercedSchema.nullable().optional();
+          } else {
+            zodShape[key] = coercedSchema;
+          }
+        } else if (fieldSchema.type === "boolean" || wrappedType === "boolean") {
+          const customBooleanCoercion = z.preprocess((val) => {
+            if (typeof val === "string") {
+              const lower = val.toLowerCase();
+              if (lower === "true" || lower === "1") return true;
+              if (lower === "false" || lower === "0") return false;
+            }
+            return val;
+          }, z.boolean());
+          if (fieldSchema.type === "optional") {
+            zodShape[key] = customBooleanCoercion.nullable().optional();
+          } else {
+            zodShape[key] = customBooleanCoercion;
+          }
+        } else {
+          zodShape[key] = baseZodSchema;
+        }
+      }
+    }
+    return z.object(zodShape);
   }
 };
 var ArraySchema = class extends BaseSchema {
+  type = "array";
   _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;
+  toZod() {
+    return z.array(this._element.toZod());
+  }
+};
+var RecordSchema = class extends BaseSchema {
+  type = "record";
+  _valueSchema;
+  constructor(valueSchema) {
+    super();
+    this._valueSchema = valueSchema;
+  }
+  toZod() {
+    return z.record(z.string(), this._valueSchema.toZod());
   }
 };
 
-// schema/nu.ts
+// src/schema/nu.ts
 var nu = {
   boolean: () => new BooleanSchema(),
   /**
@@ -130,16 +747,206 @@ var nu = {
    * 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.)
+  array: (elementSchema) => new ArraySchema(elementSchema),
+  /**
+   * Creates a record schema (dictionary) with string keys and values of a specific type.
+   * Similar to TypeScript's Record<string, T>.
+   *
+   * @example
+   * const scoresSchema = nu.record(nu.number());
+   * // Represents: { [key: string]: number }
+   *
+   * @param valueSchema The schema for values in the record.
+   */
+  record: (valueSchema) => new RecordSchema(valueSchema)
+};
+
+// src/schema/empty-schema.ts
+var emptySchema = nu.object({});
+var idNumberSchema = nu.object({
+  id: nu.number()
+});
+var idStringSchema = nu.object({
+  id: nu.string()
+});
+var successSchema = nu.object({
+  success: nu.boolean()
+});
+var successMessageSchema = nu.object({
+  success: nu.boolean(),
+  message: nu.string().optional()
+});
+var successErrorSchema = nu.object({
+  success: nu.boolean(),
+  message: nu.string().optional(),
+  errors: nu.array(
+    nu.object({
+      field: nu.string().optional(),
+      message: nu.string()
+    })
+  ).optional()
+});
+
+// src/schema/error-schema.ts
+var errorSchema = nu.object({
+  errorCode: nu.string(),
+  // required by default
+  errorMessage: nu.string()
+  // required by default
+});
+
+// src/schema/errors.ts
+var NubaseSchemaError = class _NubaseSchemaError extends Error {
+  errors;
+  constructor(errors) {
+    const message = `Schema validation failed:
+${errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n")}`;
+    super(message);
+    this.name = "NubaseSchemaError";
+    this.errors = errors;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Creates a NubaseSchemaError from a list of error messages
+   */
+  static fromMessages(errorMessages) {
+    const errors = errorMessages.map((message) => {
+      const match = message.match(/^Property '([^']+)':\s*(.+)$/);
+      if (match?.[1] && match[2]) {
+        return {
+          path: match[1],
+          message: match[2]
+        };
+      }
+      return {
+        path: "root",
+        message
+      };
+    });
+    return new _NubaseSchemaError(errors);
+  }
+  /**
+   * Type guard to check if an error is a NubaseSchemaError
+   */
+  static isNubaseSchemaError(error) {
+    return error instanceof _NubaseSchemaError;
+  }
 };
+
+// src/schema/widget-data-schema.ts
+var seriesConfigSchema = nu.object({
+  /** The data key field names that represent numeric series (e.g., ["desktop", "mobile"]) */
+  keys: nu.array(nu.string()),
+  /** Optional labels for each key (e.g., { desktop: "Desktop Users" }) */
+  labels: nu.object({}).optional(),
+  /** Optional colors for each key (e.g., { desktop: "var(--chart1)" }) */
+  colors: nu.object({}).optional()
+});
+var seriesDataPointSchema = nu.object({
+  category: nu.string()
+}).catchall(nu.number());
+var seriesDataSchema = nu.object({
+  type: nu.string(),
+  // "series"
+  config: seriesConfigSchema,
+  data: nu.array(seriesDataPointSchema)
+});
+var proportionalDataItemSchema = nu.object({
+  label: nu.string(),
+  value: nu.number()
+});
+var proportionalDataSchema = nu.object({
+  type: nu.string(),
+  // "proportional"
+  data: nu.array(proportionalDataItemSchema)
+});
+var kpiDataSchema = nu.object({
+  type: nu.string(),
+  // "kpi"
+  value: nu.string(),
+  label: nu.string().optional(),
+  trend: nu.string().optional(),
+  trendDirection: nu.string().optional()
+  // "up" | "down" | "neutral"
+});
+var tableColumnSchema = nu.object({
+  key: nu.string(),
+  label: nu.string(),
+  width: nu.string().optional()
+});
+var tableDataSchema = nu.object({
+  type: nu.string(),
+  // "table"
+  columns: nu.array(tableColumnSchema),
+  rows: nu.array(nu.object({}))
+  // Record<string, unknown>[]
+});
+
+// src/schema/widget-request-schema.ts
+function createSeriesWidgetEndpoint(path, requestParams) {
+  return {
+    method: "GET",
+    path,
+    requestParams: requestParams || emptySchema,
+    responseBody: seriesDataSchema
+  };
+}
+function createProportionalWidgetEndpoint(path, requestParams) {
+  return {
+    method: "GET",
+    path,
+    requestParams: requestParams || emptySchema,
+    responseBody: proportionalDataSchema
+  };
+}
+function createKpiWidgetEndpoint(path, requestParams) {
+  return {
+    method: "GET",
+    path,
+    requestParams: requestParams || emptySchema,
+    responseBody: kpiDataSchema
+  };
+}
+function createTableWidgetEndpoint(path, requestParams) {
+  return {
+    method: "GET",
+    path,
+    requestParams: requestParams || emptySchema,
+    responseBody: tableDataSchema
+  };
+}
 export {
   ArraySchema,
   BaseSchema,
   BooleanSchema,
+  HttpClient,
+  NubaseSchemaError,
   NumberSchema,
   ObjectSchema,
+  OptionalSchema,
+  RecordSchema,
   StringSchema,
-  nu
+  createKpiWidgetEndpoint,
+  createProportionalWidgetEndpoint,
+  createSeriesWidgetEndpoint,
+  createTableWidgetEndpoint,
+  emptySchema,
+  errorSchema,
+  idNumberSchema,
+  idStringSchema,
+  kpiDataSchema,
+  nu,
+  proportionalDataItemSchema,
+  proportionalDataSchema,
+  seriesConfigSchema,
+  seriesDataPointSchema,
+  seriesDataSchema,
+  successErrorSchema,
+  successMessageSchema,
+  successSchema,
+  tableColumnSchema,
+  tableDataSchema
 };
 //# sourceMappingURL=index.mjs.map