@plures/praxis 1.0.3 → 1.1.0

package/dist/node/chunk-UATVJBNV.js

@@ -0,0 +1,175 @@
+// src/core/schema/types.ts
+function validateSchema(schema) {
+  const errors = [];
+  if (!schema.version) {
+    errors.push({ path: "version", message: "Schema version is required" });
+  }
+  if (!schema.name) {
+    errors.push({ path: "name", message: "Schema name is required" });
+  }
+  if (schema.models) {
+    schema.models.forEach((model, index) => {
+      if (!model.name) {
+        errors.push({
+          path: `models[${index}].name`,
+          message: "Model name is required"
+        });
+      }
+      if (!model.fields || model.fields.length === 0) {
+        errors.push({
+          path: `models[${index}].fields`,
+          message: "Model must have at least one field"
+        });
+      }
+    });
+  }
+  if (schema.components) {
+    schema.components.forEach((component, index) => {
+      if (!component.name) {
+        errors.push({
+          path: `components[${index}].name`,
+          message: "Component name is required"
+        });
+      }
+      if (!component.type) {
+        errors.push({
+          path: `components[${index}].type`,
+          message: "Component type is required"
+        });
+      }
+    });
+  }
+  if (schema.logic) {
+    schema.logic.forEach((logic, logicIndex) => {
+      if (logic.facts) {
+        logic.facts.forEach((fact, factIndex) => {
+          if (!fact.tag) {
+            errors.push({
+              path: `logic[${logicIndex}].facts[${factIndex}].tag`,
+              message: "Fact tag is required"
+            });
+          } else if (!isValidIdentifier(fact.tag)) {
+            errors.push({
+              path: `logic[${logicIndex}].facts[${factIndex}].tag`,
+              message: `Fact tag "${fact.tag}" is not a valid JavaScript identifier. Use only letters, numbers, underscores, and dollar signs, and do not start with a number.`
+            });
+          }
+        });
+      }
+      if (logic.events) {
+        logic.events.forEach((event, eventIndex) => {
+          if (!event.tag) {
+            errors.push({
+              path: `logic[${logicIndex}].events[${eventIndex}].tag`,
+              message: "Event tag is required"
+            });
+          } else if (!isValidIdentifier(event.tag)) {
+            errors.push({
+              path: `logic[${logicIndex}].events[${eventIndex}].tag`,
+              message: `Event tag "${event.tag}" is not a valid JavaScript identifier. Use only letters, numbers, underscores, and dollar signs, and do not start with a number.`
+            });
+          }
+        });
+      }
+    });
+  }
+  if (schema.orchestration?.nodes) {
+    schema.orchestration.nodes.forEach((node, index) => {
+      if (!node.id) {
+        errors.push({
+          path: `orchestration.nodes[${index}].id`,
+          message: "Node id is required"
+        });
+      }
+      if (!node.type) {
+        errors.push({
+          path: `orchestration.nodes[${index}].type`,
+          message: "Node type is required"
+        });
+      }
+      if (node.type === "terminal" && node.props) {
+        const props = node.props;
+        if (props.inputMode && !["text", "widget"].includes(props.inputMode)) {
+          errors.push({
+            path: `orchestration.nodes[${index}].props.inputMode`,
+            message: 'Terminal node inputMode must be "text" or "widget"'
+          });
+        }
+        if (props.history && !Array.isArray(props.history)) {
+          errors.push({
+            path: `orchestration.nodes[${index}].props.history`,
+            message: "Terminal node history must be an array"
+          });
+        }
+      }
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidIdentifier(str) {
+  const identifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+  const reservedKeywords = [
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "let",
+    "static",
+    "enum",
+    "await",
+    "implements",
+    "interface",
+    "package",
+    "private",
+    "protected",
+    "public"
+  ];
+  return identifierRegex.test(str) && !reservedKeywords.includes(str);
+}
+function createSchemaTemplate(name) {
+  return {
+    version: "1.0.0",
+    name,
+    description: `Schema for ${name}`,
+    models: [],
+    components: [],
+    logic: []
+  };
+}
+
+export {
+  validateSchema,
+  createSchemaTemplate
+};

package/dist/node/chunk-UY7YEBE2.js

@@ -0,0 +1,159 @@
+import {
+  validateSchema
+} from "./chunk-UATVJBNV.js";
+
+// src/core/schema/loader.common.ts
+import { load as yamlLoad } from "js-yaml";
+function loadSchemaFromJson(json, options = {}) {
+  const errors = [];
+  try {
+    const schema = JSON.parse(json);
+    let validation;
+    if (options.validate !== false) {
+      validation = validateSchema(schema);
+      if (!validation.valid) {
+        errors.push("Schema validation failed:");
+        validation.errors.forEach((error) => {
+          errors.push(`  ${error.path}: ${error.message}`);
+        });
+      }
+    }
+    return {
+      schema,
+      validation,
+      errors
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      errors.push(`Failed to parse JSON: ${error.message}`);
+    } else {
+      errors.push("Failed to parse JSON: Unknown error");
+    }
+    return { errors };
+  }
+}
+function loadSchemaFromYaml(yaml, options = {}) {
+  const errors = [];
+  try {
+    const schema = yamlLoad(yaml);
+    let validation;
+    if (options.validate !== false) {
+      validation = validateSchema(schema);
+      if (!validation.valid) {
+        errors.push("Schema validation failed:");
+        validation.errors.forEach((error) => {
+          errors.push(`  ${error.path}: ${error.message}`);
+        });
+      }
+    }
+    return {
+      schema,
+      validation,
+      errors
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      errors.push(`Failed to parse YAML: ${error.message}`);
+    } else {
+      errors.push("Failed to parse YAML: Unknown error");
+    }
+    return { errors };
+  }
+}
+function validateForGeneration(schema) {
+  const errors = [];
+  if (!schema.models || schema.models.length === 0) {
+    errors.push("Schema must define at least one model for generation");
+  }
+  schema.models?.forEach((model, index) => {
+    if (!model.fields || model.fields.length === 0) {
+      errors.push(`Model "${model.name}" at index ${index} must have at least one field`);
+    }
+    model.fields?.forEach((field, fieldIndex) => {
+      if (!field.name) {
+        errors.push(`Field at index ${fieldIndex} in model "${model.name}" must have a name`);
+      }
+      if (!field.type) {
+        errors.push(`Field "${field.name}" in model "${model.name}" must have a type`);
+      }
+    });
+  });
+  return {
+    valid: errors.length === 0,
+    errors: errors.map((message) => ({ path: "schema", message }))
+  };
+}
+
+// src/core/schema/loader.ts
+import { readFile } from "fs/promises";
+import { pathToFileURL } from "url";
+async function loadSchema(filePath, options = {}) {
+  const errors = [];
+  try {
+    let fileUrl = pathToFileURL(filePath).href;
+    const module = await import(fileUrl);
+    let schema;
+    if (module.default) {
+      schema = module.default;
+    } else if (module.schema) {
+      schema = module.schema;
+    } else if (module.appSchema) {
+      schema = module.appSchema;
+    } else {
+      const exports = Object.values(module);
+      const possibleSchema = exports.find(
+        (exp) => typeof exp === "object" && exp !== null && "version" in exp && "name" in exp
+      );
+      if (possibleSchema) {
+        schema = possibleSchema;
+      }
+    }
+    if (!schema) {
+      errors.push(
+        "Schema file must export a PraxisSchema object (as default, schema, or appSchema)"
+      );
+      return { errors };
+    }
+    let validation;
+    if (options.validate !== false) {
+      validation = validateSchema(schema);
+      if (!validation.valid) {
+        errors.push("Schema validation failed:");
+        validation.errors.forEach((error) => {
+          errors.push(`  ${error.path}: ${error.message}`);
+        });
+      }
+    }
+    return {
+      schema,
+      validation,
+      errors
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      errors.push(`Failed to load schema: ${error.message}`);
+    } else {
+      errors.push("Failed to load schema: Unknown error");
+    }
+    return { errors };
+  }
+}
+async function loadSchemaFromFile(filePath, options = {}) {
+  if (filePath.endsWith(".json")) {
+    const content = await readFile(filePath, "utf-8");
+    return loadSchemaFromJson(content, options);
+  } else if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+    const content = await readFile(filePath, "utf-8");
+    return loadSchemaFromYaml(content, options);
+  } else {
+    return loadSchema(filePath, options);
+  }
+}
+
+export {
+  loadSchemaFromJson,
+  loadSchemaFromYaml,
+  validateForGeneration,
+  loadSchema,
+  loadSchemaFromFile
+};

package/dist/node/chunk-XCY2VIFX.js

@@ -0,0 +1,143 @@
+// src/cloud/client.ts
+function createCloudRelay(config) {
+  let status = {
+    connected: false,
+    endpoint: config.endpoint,
+    appId: config.appId
+  };
+  let syncTimer = null;
+  const vectorClock = {};
+  return {
+    async connect() {
+      if (!config.endpoint) {
+        throw new Error("Cloud relay endpoint is required");
+      }
+      try {
+        const response = await fetch(`${config.endpoint}/health`, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.authToken && {
+              Authorization: `Bearer ${config.authToken}`
+            }
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`Health check failed: ${response.statusText}`);
+        }
+        status.connected = true;
+        status.lastSync = Date.now();
+        if (config.autoSync) {
+          const interval = config.syncInterval || 5e3;
+          syncTimer = setInterval(() => {
+            status.lastSync = Date.now();
+          }, interval);
+        }
+      } catch (error) {
+        status.connected = false;
+        throw new Error(
+          `Failed to connect to cloud relay: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    async disconnect() {
+      if (syncTimer) {
+        clearInterval(syncTimer);
+        syncTimer = null;
+      }
+      status.connected = false;
+    },
+    async sync(message) {
+      if (!status.connected) {
+        throw new Error("Not connected to cloud relay");
+      }
+      vectorClock[config.appId] = (vectorClock[config.appId] || 0) + 1;
+      message.clock = { ...vectorClock };
+      try {
+        const response = await fetch(`${config.endpoint}/sync`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.authToken && {
+              Authorization: `Bearer ${config.authToken}`
+            }
+          },
+          body: JSON.stringify(message)
+        });
+        if (!response.ok) {
+          throw new Error(`Sync failed: ${response.statusText}`);
+        }
+        status.lastSync = Date.now();
+        const result = await response.json();
+        if (result.clock) {
+          Object.entries(result.clock).forEach(([key, value]) => {
+            vectorClock[key] = Math.max(vectorClock[key] || 0, value);
+          });
+        }
+      } catch (error) {
+        throw new Error(
+          `Failed to sync: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    async getUsage() {
+      if (!status.connected) {
+        throw new Error("Not connected to cloud relay");
+      }
+      try {
+        const response = await fetch(`${config.endpoint}/usage?appId=${config.appId}`, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.authToken && {
+              Authorization: `Bearer ${config.authToken}`
+            }
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`Failed to get usage: ${response.statusText}`);
+        }
+        return await response.json();
+      } catch (error) {
+        throw new Error(
+          `Failed to get usage metrics: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    async getHealth() {
+      try {
+        const response = await fetch(`${config.endpoint}/health`, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`Health check failed: ${response.statusText}`);
+        }
+        return await response.json();
+      } catch (error) {
+        throw new Error(
+          `Failed to get health status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    getStatus() {
+      return { ...status };
+    }
+  };
+}
+async function connectRelay(endpoint, options = { appId: "default" }) {
+  const config = {
+    endpoint,
+    ...options
+  };
+  const client = createCloudRelay(config);
+  await client.connect();
+  return client;
+}
+
+export {
+  createCloudRelay,
+  connectRelay
+};