@opendatalabs/vana-sdk 0.1.0-alpha.e9cead7 → 0.1.0-alpha.eebb656

package/dist/utils/schemaValidation.cjs

@@ -0,0 +1,258 @@
+"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);
+var schemaValidation_exports = {};
+__export(schemaValidation_exports, {
+  SchemaValidationError: () => SchemaValidationError,
+  SchemaValidator: () => SchemaValidator,
+  fetchAndValidateSchema: () => fetchAndValidateSchema,
+  schemaValidator: () => schemaValidator,
+  validateDataAgainstSchema: () => validateDataAgainstSchema,
+  validateDataSchemaAgainstMetaSchema: () => validateDataSchemaAgainstMetaSchema
+});
+module.exports = __toCommonJS(schemaValidation_exports);
+var import_ajv = __toESM(require("ajv"), 1);
+var import_ajv_formats = __toESM(require("ajv-formats"), 1);
+var import_dataSchema_schema = __toESM(require("../schemas/dataSchema.schema.json"), 1);
+class SchemaValidationError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "SchemaValidationError";
+  }
+}
+class SchemaValidator {
+  ajv;
+  dataSchemaValidator;
+  constructor() {
+    this.ajv = new import_ajv.default({
+      allErrors: true,
+      verbose: true,
+      strict: false
+    });
+    (0, import_ajv_formats.default)(this.ajv);
+    this.dataSchemaValidator = this.ajv.compile(import_dataSchema_schema.default);
+  }
+  /**
+   * Validates a data schema definition against the Vana meta-schema
+   *
+   * @param schema - The data schema definition to validate
+   * @throws SchemaValidationError if invalid
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator();
+   *
+   * const schema = {
+   *   name: "User Profile",
+   *   version: "1.0.0",
+   *   dialect: "json",
+   *   schema: {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       age: { type: "number" }
+   *     }
+   *   }
+   * };
+   *
+   * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid
+   * ```
+   */
+  validateDataSchemaAgainstMetaSchema(schema) {
+    const isValid = this.dataSchemaValidator(schema);
+    if (!isValid) {
+      const errors = this.dataSchemaValidator.errors ?? [];
+      const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
+      throw new SchemaValidationError(errorMessage, errors);
+    }
+    const typedSchema = schema;
+    if (typedSchema.dialect === "json" && typeof typedSchema.schema === "object") {
+      try {
+        this.ajv.compile(typedSchema.schema);
+      } catch (error) {
+        const errorMessage = `Invalid JSON Schema in data schema: ${error instanceof Error ? error.message : "Unknown schema compilation error"}`;
+        throw new SchemaValidationError(errorMessage, []);
+      }
+    } else if (typedSchema.dialect === "sqlite" && typeof typedSchema.schema === "string") {
+      this.validateSQLiteDDL(typedSchema.schema, typedSchema.dialectVersion);
+    }
+  }
+  /**
+   * Validates data against a JSON Schema
+   *
+   * @param data - The data to validate
+   * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)
+   * @throws SchemaValidationError if invalid
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator();
+   *
+   * // Works with Schema from schemas.get()
+   * const schema = await vana.schemas.get(1);
+   * validator.validateDataAgainstSchema(userData, schema);
+   *
+   * // Also works with pre-validated DataSchema object
+   * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({
+   *   name: "User Profile",
+   *   version: "1.0.0",
+   *   dialect: "json",
+   *   schema: { type: "object", properties: { name: { type: "string" } } }
+   * });
+   * validator.validateDataAgainstSchema(userData, dataSchema);
+   * ```
+   */
+  validateDataAgainstSchema(data, schema) {
+    if (schema.dialect !== "json") {
+      console.warn(
+        `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. Only JSON schemas can validate data structure.`
+      );
+      return;
+    }
+    if (typeof schema.schema !== "object") {
+      throw new SchemaValidationError(
+        "JSON dialect schemas must have an object schema",
+        []
+      );
+    }
+    const dataValidator = this.ajv.compile(schema.schema);
+    const isValid = dataValidator(data);
+    if (!isValid) {
+      const errors = dataValidator.errors ?? [];
+      const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
+      throw new SchemaValidationError(errorMessage, errors);
+    }
+  }
+  /**
+   * Validates a SQLite DDL string for basic syntax
+   * Note: This is a basic validation, full SQL parsing would require a proper SQL parser
+   *
+   * @param ddl - The DDL string to validate
+   * @param dialectVersion - Optional SQLite version (e.g., "3" for SQLite v3)
+   * @throws SchemaValidationError if invalid
+   */
+  validateSQLiteDDL(ddl, dialectVersion) {
+    if (typeof ddl !== "string" || ddl.trim().length === 0) {
+      throw new SchemaValidationError(
+        "SQLite DDL must be a non-empty string",
+        []
+      );
+    }
+    if (dialectVersion !== void 0) {
+      const supportedVersions = ["3"];
+      if (!supportedVersions.includes(dialectVersion)) {
+        throw new SchemaValidationError(
+          `Unsupported SQLite dialect version: ${dialectVersion}. Supported versions: ${supportedVersions.join(", ")}`,
+          []
+        );
+      }
+    }
+    const normalizedDDL = ddl.trim().toUpperCase();
+    if (!normalizedDDL.includes("CREATE TABLE")) {
+      throw new SchemaValidationError(
+        "SQLite DDL must contain at least one CREATE TABLE statement",
+        []
+      );
+    }
+    let parenCount = 0;
+    for (const char of ddl) {
+      if (char === "(") parenCount++;
+      if (char === ")") parenCount--;
+      if (parenCount < 0) {
+        throw new SchemaValidationError(
+          "SQLite DDL has unbalanced parentheses",
+          []
+        );
+      }
+    }
+    if (parenCount !== 0) {
+      throw new SchemaValidationError(
+        "SQLite DDL has unbalanced parentheses",
+        []
+      );
+    }
+  }
+  /**
+   * Fetches and validates a data schema from a URL
+   *
+   * @param url - The URL to fetch the data schema from
+   * @param downloadRelayer - Optional download relayer for CORS bypass
+   * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
+   * @returns The validated data schema
+   * @throws SchemaValidationError if invalid or fetch fails
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator();
+   * const schema = await validator.fetchAndValidateSchema("https://example.com/schema.json");
+   * ```
+   */
+  async fetchAndValidateSchema(url, downloadRelayer) {
+    try {
+      const { universalFetch } = await import("./download");
+      const response = await universalFetch(url, downloadRelayer);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const schema = await response.json();
+      this.validateDataSchemaAgainstMetaSchema(schema);
+      if (schema.dialect === "sqlite" && typeof schema.schema === "string") {
+        this.validateSQLiteDDL(schema.schema, schema.dialectVersion);
+      }
+      return schema;
+    } catch (error) {
+      if (error instanceof SchemaValidationError) {
+        throw error;
+      }
+      throw new SchemaValidationError(
+        `Failed to fetch and validate schema from ${url}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        []
+      );
+    }
+  }
+}
+const schemaValidator = new SchemaValidator();
+function validateDataSchemaAgainstMetaSchema(schema) {
+  const validator = schemaValidator;
+  validator.validateDataSchemaAgainstMetaSchema(schema);
+  return schema;
+}
+function validateDataAgainstSchema(data, schema) {
+  schemaValidator.validateDataAgainstSchema(data, schema);
+}
+function fetchAndValidateSchema(url, downloadRelayer) {
+  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaValidationError,
+  SchemaValidator,
+  fetchAndValidateSchema,
+  schemaValidator,
+  validateDataAgainstSchema,
+  validateDataSchemaAgainstMetaSchema
+});
+//# sourceMappingURL=schemaValidation.cjs.map

package/dist/utils/schemaValidation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/schemaValidation.ts"],"sourcesContent":["import Ajv, { type ValidateFunction } from \"ajv\";\nimport addFormats from \"ajv-formats\";\nimport dataSchemaSchema from \"../schemas/dataSchema.schema.json\";\nimport type { Schema } from \"../types/data\";\n\n/**\n * Data schema interface following the Vana schema specification\n *\n * @category Configuration\n */\nexport interface DataSchema {\n  /** The name of the data schema */\n  name: string;\n  /** The version of the data schema */\n  version: string;\n  /** Optional description of the data schema */\n  description?: string;\n  /** The dialect type - either SQLite or JSON */\n  dialect: \"sqlite\" | \"json\";\n  /** Optional version of the dialect */\n  dialectVersion?: string;\n  /** The actual schema definition as string or object */\n  schema: string | object;\n}\n\n/**\n * Error thrown when schema validation fails\n */\nexport class SchemaValidationError extends Error {\n  constructor(\n    message: string,\n    public errors: Array<{\n      instancePath: string;\n      schemaPath: string;\n      keyword: string;\n      params: Record<string, unknown>;\n      message?: string;\n    }>,\n  ) {\n    super(message);\n    this.name = \"SchemaValidationError\";\n  }\n}\n\n/**\n * Data schema validation utility class\n */\nexport class SchemaValidator {\n  private ajv: Ajv;\n  private dataSchemaValidator: ValidateFunction;\n\n  constructor() {\n    this.ajv = new Ajv({\n      allErrors: true,\n      verbose: true,\n      strict: false,\n    });\n\n    // Add format validation (e.g., date, email, uri)\n    addFormats(this.ajv);\n\n    // Compile the data schema meta-schema validator\n    this.dataSchemaValidator = this.ajv.compile(dataSchemaSchema);\n  }\n\n  /**\n   * Validates a data schema definition against the Vana meta-schema\n   *\n   * @param schema - The data schema definition to validate\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * const schema = {\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: {\n   *     type: \"object\",\n   *     properties: {\n   *       name: { type: \"string\" },\n   *       age: { type: \"number\" }\n   *     }\n   *   }\n   * };\n   *\n   * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid\n   * ```\n   */\n  validateDataSchemaAgainstMetaSchema(\n    schema: unknown,\n  ): asserts schema is DataSchema {\n    const isValid = this.dataSchemaValidator(schema);\n\n    if (!isValid) {\n      const errors = this.dataSchemaValidator.errors ?? [];\n      const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n\n    // Additional validation based on dialect\n    const typedSchema = schema as DataSchema;\n    if (\n      typedSchema.dialect === \"json\" &&\n      typeof typedSchema.schema === \"object\"\n    ) {\n      // Validate that the embedded JSON Schema is actually valid\n      try {\n        this.ajv.compile(typedSchema.schema);\n      } catch (error) {\n        const errorMessage = `Invalid JSON Schema in data schema: ${error instanceof Error ? error.message : \"Unknown schema compilation error\"}`;\n        throw new SchemaValidationError(errorMessage, []);\n      }\n    } else if (\n      typedSchema.dialect === \"sqlite\" &&\n      typeof typedSchema.schema === \"string\"\n    ) {\n      // Validate SQLite DDL syntax\n      this.validateSQLiteDDL(typedSchema.schema, typedSchema.dialectVersion);\n    }\n  }\n\n  /**\n   * Validates data against a JSON Schema\n   *\n   * @param data - The data to validate\n   * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)\n   * @throws SchemaValidationError if invalid\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   *\n   * // Works with Schema from schemas.get()\n   * const schema = await vana.schemas.get(1);\n   * validator.validateDataAgainstSchema(userData, schema);\n   *\n   * // Also works with pre-validated DataSchema object\n   * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({\n   *   name: \"User Profile\",\n   *   version: \"1.0.0\",\n   *   dialect: \"json\",\n   *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n   * });\n   * validator.validateDataAgainstSchema(userData, dataSchema);\n   * ```\n   */\n  validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void {\n    if (schema.dialect !== \"json\") {\n      console.warn(\n        `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. ` +\n          `Only JSON schemas can validate data structure.`,\n      );\n      return;\n    }\n\n    if (typeof schema.schema !== \"object\") {\n      throw new SchemaValidationError(\n        \"JSON dialect schemas must have an object schema\",\n        [],\n      );\n    }\n\n    // Compile and validate against the data schema\n    const dataValidator = this.ajv.compile(schema.schema);\n    const isValid = dataValidator(data);\n\n    if (!isValid) {\n      const errors = dataValidator.errors ?? [];\n      const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(\", \")}`;\n      throw new SchemaValidationError(errorMessage, errors);\n    }\n  }\n\n  /**\n   * Validates a SQLite DDL string for basic syntax\n   * Note: This is a basic validation, full SQL parsing would require a proper SQL parser\n   *\n   * @param ddl - The DDL string to validate\n   * @param dialectVersion - Optional SQLite version (e.g., \"3\" for SQLite v3)\n   * @throws SchemaValidationError if invalid\n   */\n  validateSQLiteDDL(ddl: string, dialectVersion?: string): void {\n    if (typeof ddl !== \"string\" || ddl.trim().length === 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must be a non-empty string\",\n        [],\n      );\n    }\n\n    // Validate dialectVersion if provided\n    if (dialectVersion !== undefined) {\n      const supportedVersions = [\"3\"];\n      if (!supportedVersions.includes(dialectVersion)) {\n        throw new SchemaValidationError(\n          `Unsupported SQLite dialect version: ${dialectVersion}. Supported versions: ${supportedVersions.join(\", \")}`,\n          [],\n        );\n      }\n    }\n\n    // Basic validation - check for CREATE TABLE statements\n    const normalizedDDL = ddl.trim().toUpperCase();\n    if (!normalizedDDL.includes(\"CREATE TABLE\")) {\n      throw new SchemaValidationError(\n        \"SQLite DDL must contain at least one CREATE TABLE statement\",\n        [],\n      );\n    }\n\n    // Check for balanced parentheses\n    let parenCount = 0;\n    for (const char of ddl) {\n      if (char === \"(\") parenCount++;\n      if (char === \")\") parenCount--;\n      if (parenCount < 0) {\n        throw new SchemaValidationError(\n          \"SQLite DDL has unbalanced parentheses\",\n          [],\n        );\n      }\n    }\n\n    if (parenCount !== 0) {\n      throw new SchemaValidationError(\n        \"SQLite DDL has unbalanced parentheses\",\n        [],\n      );\n    }\n  }\n\n  /**\n   * Fetches and validates a data schema from a URL\n   *\n   * @param url - The URL to fetch the data schema from\n   * @param downloadRelayer - Optional download relayer for CORS bypass\n   * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n   * @returns The validated data schema\n   * @throws SchemaValidationError if invalid or fetch fails\n   * @example\n   * ```typescript\n   * const validator = new SchemaValidator();\n   * const schema = await validator.fetchAndValidateSchema(\"https://example.com/schema.json\");\n   * ```\n   */\n  async fetchAndValidateSchema(\n    url: string,\n    downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n  ): Promise<DataSchema> {\n    try {\n      const { universalFetch } = await import(\"./download\");\n      const response = await universalFetch(url, downloadRelayer);\n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n\n      const schema = await response.json();\n      this.validateDataSchemaAgainstMetaSchema(schema);\n\n      // Additional validation based on dialect\n      if (schema.dialect === \"sqlite\" && typeof schema.schema === \"string\") {\n        this.validateSQLiteDDL(schema.schema, schema.dialectVersion);\n      }\n\n      return schema;\n    } catch (error) {\n      if (error instanceof SchemaValidationError) {\n        throw error;\n      }\n\n      throw new SchemaValidationError(\n        `Failed to fetch and validate schema from ${url}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n        [],\n      );\n    }\n  }\n}\n\n/**\n * Global schema validator instance\n */\nexport const schemaValidator = new SchemaValidator();\n\n/**\n * Convenience function to validate a data schema definition against the Vana meta-schema\n *\n * @param schema - The data schema definition to validate\n * @returns The validated DataSchema\n * @throws SchemaValidationError if invalid\n * @example\n * ```typescript\n * const schemaDefinition = {\n *   name: \"User Profile\",\n *   version: \"1.0.0\",\n *   dialect: \"json\",\n *   schema: { type: \"object\", properties: { name: { type: \"string\" } } }\n * };\n *\n * const validatedSchema = validateDataSchemaAgainstMetaSchema(schemaDefinition);\n * ```\n */\nexport function validateDataSchemaAgainstMetaSchema(\n  schema: unknown,\n): DataSchema {\n  const validator: SchemaValidator = schemaValidator;\n  validator.validateDataSchemaAgainstMetaSchema(schema);\n  // If we get here, schema is valid and typed as DataSchema\n  return schema;\n}\n\n/**\n * Convenience function to validate data against a schema\n *\n * @param data - The data to validate\n * @param schema - The data schema containing the schema\n * @returns void - Function doesn't return a value\n * @throws SchemaValidationError if invalid\n */\nexport function validateDataAgainstSchema(\n  data: unknown,\n  schema: DataSchema | Schema,\n): void {\n  schemaValidator.validateDataAgainstSchema(data, schema);\n}\n\n/**\n * Convenience function to fetch and validate a data schema from a URL\n *\n * @param url - The URL to fetch the data schema from\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns The validated data schema\n * @throws SchemaValidationError if invalid or fetch fails\n */\nexport function fetchAndValidateSchema(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<DataSchema> {\n  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);\n}\n"],"mappings":"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","names":["Ajv","addFormats","dataSchemaSchema"]}

package/dist/utils/schemaValidation.d.ts

@@ -0,0 +1,168 @@
+import type { Schema } from "../types/data";
+/**
+ * Data schema interface following the Vana schema specification
+ *
+ * @category Configuration
+ */
+export interface DataSchema {
+    /** The name of the data schema */
+    name: string;
+    /** The version of the data schema */
+    version: string;
+    /** Optional description of the data schema */
+    description?: string;
+    /** The dialect type - either SQLite or JSON */
+    dialect: "sqlite" | "json";
+    /** Optional version of the dialect */
+    dialectVersion?: string;
+    /** The actual schema definition as string or object */
+    schema: string | object;
+}
+/**
+ * Error thrown when schema validation fails
+ */
+export declare class SchemaValidationError extends Error {
+    errors: Array<{
+        instancePath: string;
+        schemaPath: string;
+        keyword: string;
+        params: Record<string, unknown>;
+        message?: string;
+    }>;
+    constructor(message: string, errors: Array<{
+        instancePath: string;
+        schemaPath: string;
+        keyword: string;
+        params: Record<string, unknown>;
+        message?: string;
+    }>);
+}
+/**
+ * Data schema validation utility class
+ */
+export declare class SchemaValidator {
+    private ajv;
+    private dataSchemaValidator;
+    constructor();
+    /**
+     * Validates a data schema definition against the Vana meta-schema
+     *
+     * @param schema - The data schema definition to validate
+     * @throws SchemaValidationError if invalid
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator();
+     *
+     * const schema = {
+     *   name: "User Profile",
+     *   version: "1.0.0",
+     *   dialect: "json",
+     *   schema: {
+     *     type: "object",
+     *     properties: {
+     *       name: { type: "string" },
+     *       age: { type: "number" }
+     *     }
+     *   }
+     * };
+     *
+     * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid
+     * ```
+     */
+    validateDataSchemaAgainstMetaSchema(schema: unknown): asserts schema is DataSchema;
+    /**
+     * Validates data against a JSON Schema
+     *
+     * @param data - The data to validate
+     * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)
+     * @throws SchemaValidationError if invalid
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator();
+     *
+     * // Works with Schema from schemas.get()
+     * const schema = await vana.schemas.get(1);
+     * validator.validateDataAgainstSchema(userData, schema);
+     *
+     * // Also works with pre-validated DataSchema object
+     * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({
+     *   name: "User Profile",
+     *   version: "1.0.0",
+     *   dialect: "json",
+     *   schema: { type: "object", properties: { name: { type: "string" } } }
+     * });
+     * validator.validateDataAgainstSchema(userData, dataSchema);
+     * ```
+     */
+    validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void;
+    /**
+     * Validates a SQLite DDL string for basic syntax
+     * Note: This is a basic validation, full SQL parsing would require a proper SQL parser
+     *
+     * @param ddl - The DDL string to validate
+     * @param dialectVersion - Optional SQLite version (e.g., "3" for SQLite v3)
+     * @throws SchemaValidationError if invalid
+     */
+    validateSQLiteDDL(ddl: string, dialectVersion?: string): void;
+    /**
+     * Fetches and validates a data schema from a URL
+     *
+     * @param url - The URL to fetch the data schema from
+     * @param downloadRelayer - Optional download relayer for CORS bypass
+     * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
+     * @returns The validated data schema
+     * @throws SchemaValidationError if invalid or fetch fails
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator();
+     * const schema = await validator.fetchAndValidateSchema("https://example.com/schema.json");
+     * ```
+     */
+    fetchAndValidateSchema(url: string, downloadRelayer?: {
+        proxyDownload: (url: string) => Promise<Blob>;
+    }): Promise<DataSchema>;
+}
+/**
+ * Global schema validator instance
+ */
+export declare const schemaValidator: SchemaValidator;
+/**
+ * Convenience function to validate a data schema definition against the Vana meta-schema
+ *
+ * @param schema - The data schema definition to validate
+ * @returns The validated DataSchema
+ * @throws SchemaValidationError if invalid
+ * @example
+ * ```typescript
+ * const schemaDefinition = {
+ *   name: "User Profile",
+ *   version: "1.0.0",
+ *   dialect: "json",
+ *   schema: { type: "object", properties: { name: { type: "string" } } }
+ * };
+ *
+ * const validatedSchema = validateDataSchemaAgainstMetaSchema(schemaDefinition);
+ * ```
+ */
+export declare function validateDataSchemaAgainstMetaSchema(schema: unknown): DataSchema;
+/**
+ * Convenience function to validate data against a schema
+ *
+ * @param data - The data to validate
+ * @param schema - The data schema containing the schema
+ * @returns void - Function doesn't return a value
+ * @throws SchemaValidationError if invalid
+ */
+export declare function validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void;
+/**
+ * Convenience function to fetch and validate a data schema from a URL
+ *
+ * @param url - The URL to fetch the data schema from
+ * @param downloadRelayer - Optional download relayer for CORS bypass
+ * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
+ * @returns The validated data schema
+ * @throws SchemaValidationError if invalid or fetch fails
+ */
+export declare function fetchAndValidateSchema(url: string, downloadRelayer?: {
+    proxyDownload: (url: string) => Promise<Blob>;
+}): Promise<DataSchema>;

package/dist/utils/schemaValidation.js

@@ -0,0 +1,219 @@
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import dataSchemaSchema from "../schemas/dataSchema.schema.json";
+class SchemaValidationError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "SchemaValidationError";
+  }
+}
+class SchemaValidator {
+  ajv;
+  dataSchemaValidator;
+  constructor() {
+    this.ajv = new Ajv({
+      allErrors: true,
+      verbose: true,
+      strict: false
+    });
+    addFormats(this.ajv);
+    this.dataSchemaValidator = this.ajv.compile(dataSchemaSchema);
+  }
+  /**
+   * Validates a data schema definition against the Vana meta-schema
+   *
+   * @param schema - The data schema definition to validate
+   * @throws SchemaValidationError if invalid
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator();
+   *
+   * const schema = {
+   *   name: "User Profile",
+   *   version: "1.0.0",
+   *   dialect: "json",
+   *   schema: {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       age: { type: "number" }
+   *     }
+   *   }
+   * };
+   *
+   * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid
+   * ```
+   */
+  validateDataSchemaAgainstMetaSchema(schema) {
+    const isValid = this.dataSchemaValidator(schema);
+    if (!isValid) {
+      const errors = this.dataSchemaValidator.errors ?? [];
+      const errorMessage = `Data schema validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
+      throw new SchemaValidationError(errorMessage, errors);
+    }
+    const typedSchema = schema;
+    if (typedSchema.dialect === "json" && typeof typedSchema.schema === "object") {
+      try {
+        this.ajv.compile(typedSchema.schema);
+      } catch (error) {
+        const errorMessage = `Invalid JSON Schema in data schema: ${error instanceof Error ? error.message : "Unknown schema compilation error"}`;
+        throw new SchemaValidationError(errorMessage, []);
+      }
+    } else if (typedSchema.dialect === "sqlite" && typeof typedSchema.schema === "string") {
+      this.validateSQLiteDDL(typedSchema.schema, typedSchema.dialectVersion);
+    }
+  }
+  /**
+   * Validates data against a JSON Schema
+   *
+   * @param data - The data to validate
+   * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)
+   * @throws SchemaValidationError if invalid
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator();
+   *
+   * // Works with Schema from schemas.get()
+   * const schema = await vana.schemas.get(1);
+   * validator.validateDataAgainstSchema(userData, schema);
+   *
+   * // Also works with pre-validated DataSchema object
+   * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({
+   *   name: "User Profile",
+   *   version: "1.0.0",
+   *   dialect: "json",
+   *   schema: { type: "object", properties: { name: { type: "string" } } }
+   * });
+   * validator.validateDataAgainstSchema(userData, dataSchema);
+   * ```
+   */
+  validateDataAgainstSchema(data, schema) {
+    if (schema.dialect !== "json") {
+      console.warn(
+        `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. Only JSON schemas can validate data structure.`
+      );
+      return;
+    }
+    if (typeof schema.schema !== "object") {
+      throw new SchemaValidationError(
+        "JSON dialect schemas must have an object schema",
+        []
+      );
+    }
+    const dataValidator = this.ajv.compile(schema.schema);
+    const isValid = dataValidator(data);
+    if (!isValid) {
+      const errors = dataValidator.errors ?? [];
+      const errorMessage = `Data validation failed: ${errors.map((e) => `${e.instancePath} ${e.message}`).join(", ")}`;
+      throw new SchemaValidationError(errorMessage, errors);
+    }
+  }
+  /**
+   * Validates a SQLite DDL string for basic syntax
+   * Note: This is a basic validation, full SQL parsing would require a proper SQL parser
+   *
+   * @param ddl - The DDL string to validate
+   * @param dialectVersion - Optional SQLite version (e.g., "3" for SQLite v3)
+   * @throws SchemaValidationError if invalid
+   */
+  validateSQLiteDDL(ddl, dialectVersion) {
+    if (typeof ddl !== "string" || ddl.trim().length === 0) {
+      throw new SchemaValidationError(
+        "SQLite DDL must be a non-empty string",
+        []
+      );
+    }
+    if (dialectVersion !== void 0) {
+      const supportedVersions = ["3"];
+      if (!supportedVersions.includes(dialectVersion)) {
+        throw new SchemaValidationError(
+          `Unsupported SQLite dialect version: ${dialectVersion}. Supported versions: ${supportedVersions.join(", ")}`,
+          []
+        );
+      }
+    }
+    const normalizedDDL = ddl.trim().toUpperCase();
+    if (!normalizedDDL.includes("CREATE TABLE")) {
+      throw new SchemaValidationError(
+        "SQLite DDL must contain at least one CREATE TABLE statement",
+        []
+      );
+    }
+    let parenCount = 0;
+    for (const char of ddl) {
+      if (char === "(") parenCount++;
+      if (char === ")") parenCount--;
+      if (parenCount < 0) {
+        throw new SchemaValidationError(
+          "SQLite DDL has unbalanced parentheses",
+          []
+        );
+      }
+    }
+    if (parenCount !== 0) {
+      throw new SchemaValidationError(
+        "SQLite DDL has unbalanced parentheses",
+        []
+      );
+    }
+  }
+  /**
+   * Fetches and validates a data schema from a URL
+   *
+   * @param url - The URL to fetch the data schema from
+   * @param downloadRelayer - Optional download relayer for CORS bypass
+   * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
+   * @returns The validated data schema
+   * @throws SchemaValidationError if invalid or fetch fails
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator();
+   * const schema = await validator.fetchAndValidateSchema("https://example.com/schema.json");
+   * ```
+   */
+  async fetchAndValidateSchema(url, downloadRelayer) {
+    try {
+      const { universalFetch } = await import("./download");
+      const response = await universalFetch(url, downloadRelayer);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const schema = await response.json();
+      this.validateDataSchemaAgainstMetaSchema(schema);
+      if (schema.dialect === "sqlite" && typeof schema.schema === "string") {
+        this.validateSQLiteDDL(schema.schema, schema.dialectVersion);
+      }
+      return schema;
+    } catch (error) {
+      if (error instanceof SchemaValidationError) {
+        throw error;
+      }
+      throw new SchemaValidationError(
+        `Failed to fetch and validate schema from ${url}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        []
+      );
+    }
+  }
+}
+const schemaValidator = new SchemaValidator();
+function validateDataSchemaAgainstMetaSchema(schema) {
+  const validator = schemaValidator;
+  validator.validateDataSchemaAgainstMetaSchema(schema);
+  return schema;
+}
+function validateDataAgainstSchema(data, schema) {
+  schemaValidator.validateDataAgainstSchema(data, schema);
+}
+function fetchAndValidateSchema(url, downloadRelayer) {
+  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);
+}
+export {
+  SchemaValidationError,
+  SchemaValidator,
+  fetchAndValidateSchema,
+  schemaValidator,
+  validateDataAgainstSchema,
+  validateDataSchemaAgainstMetaSchema
+};
+//# sourceMappingURL=schemaValidation.js.map