@sixb/core 0.1.1 → 0.1.2

package/dist/chunk-sa4340y1.js

@@ -0,0 +1,607 @@
+// @bun
+import {
+  isSyncDefinition
+} from "./chunk-7pc8b818.js";
+import {
+  isPipelineDefinition
+} from "./chunk-bh6k3nc6.js";
+import {
+  allPredicates,
+  anyPredicates,
+  assertPredicateShape,
+  createLinkPredicateBuilder,
+  createPropertyPredicateBuilder,
+  isScheduleDefinition,
+  notPredicate
+} from "./chunk-5sz8ta9r.js";
+import {
+  isDatasetDefinition
+} from "./chunk-a31h57d5.js";
+import {
+  isAgentDefinition,
+  isWorkflowDefinition
+} from "./chunk-0mbx247x.js";
+import {
+  RuntimeError
+} from "./chunk-k9pts48t.js";
+import {
+  isConnectorDefinition
+} from "./chunk-8m5ejdpn.js";
+import {
+  isActionDefinition
+} from "./chunk-c6qd89g5.js";
+import {
+  isGroupDefinition,
+  isMembershipPolicyDefinition,
+  isRoleDefinition
+} from "./chunk-jaj13078.js";
+import {
+  isProjectionDefinition
+} from "./chunk-34bqh420.js";
+
+// src/bootstrap/discovery.ts
+import { readdir } from "fs/promises";
+import { join, relative } from "path";
+import { pathToFileURL } from "url";
+
+// src/rules/errors.ts
+class RuleError extends Error {
+  name = "RuleError";
+}
+
+class RuleValidationError extends RuleError {
+  name = "RuleValidationError";
+}
+
+// src/rules/validation.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertNonEmptyString(value, field, createError) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw createError(`${field} must not be empty.`);
+  }
+}
+function assertRulePredicateShape(value, createError = (message) => new RuleValidationError(message)) {
+  assertPredicateShape(value, { subject: "Rule", createError });
+}
+function assertRuleDefinition(value, createError = (message) => new RuleValidationError(message)) {
+  if (!isRecord(value)) {
+    throw createError("Rule definition must be an object.");
+  }
+  if (value.kind !== "rule") {
+    throw createError("Rule definition kind must be 'rule'.");
+  }
+  assertNonEmptyString(value.id, "Rule id", createError);
+  if (!isRecord(value.subject) || value.subject.kind !== "object") {
+    throw createError(`Rule '${value.id}' subject must be an object subject.`);
+  }
+  assertNonEmptyString(value.subject.objectTypeId, `Rule '${value.id}' subject objectTypeId`, createError);
+  assertRulePredicateShape(value.predicate, createError);
+}
+function isRuleDefinition(value) {
+  try {
+    assertRuleDefinition(value, (message) => new Error(message));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateRulesAtStartup(rules, ontology) {
+  const seenRuleIds = new Set;
+  for (const rule of rules) {
+    assertRuleDefinition(rule);
+    if (seenRuleIds.has(rule.id)) {
+      throw new RuleValidationError(`Duplicate rule id: ${rule.id}`);
+    }
+    seenRuleIds.add(rule.id);
+    const objectType = ontology.getObjectTypeById(rule.subject.objectTypeId);
+    if (!objectType) {
+      throw new RuleValidationError(`Rule "${rule.id}": unknown object type "${rule.subject.objectTypeId}".`);
+    }
+    validatePredicateAgainstSubject(rule, objectType, rule.predicate);
+  }
+}
+function validatePredicateAgainstSubject(rule, objectType, predicate) {
+  if (predicate.kind === "all" || predicate.kind === "any") {
+    if (predicate.predicates.length === 0) {
+      throw new RuleValidationError(`Rule "${rule.id}": ${predicate.kind} predicate must contain at least one predicate.`);
+    }
+    for (const child of predicate.predicates) {
+      validatePredicateAgainstSubject(rule, objectType, child);
+    }
+    return;
+  }
+  if (predicate.kind === "not") {
+    validatePredicateAgainstSubject(rule, objectType, predicate.predicate);
+    return;
+  }
+  if (predicate.kind === "property") {
+    const propertyIds = new Set(objectType.properties.map((property) => property.id));
+    if (!propertyIds.has(predicate.propertyId)) {
+      throw new RuleValidationError(`Rule "${rule.id}": unknown property "${predicate.propertyId}" on object type "${objectType.id}".`);
+    }
+    return;
+  }
+  if (predicate.kind === "field") {
+    throw new RuleValidationError(`Rule "${rule.id}": field predicates are not supported in rule conditions.`);
+  }
+  const linkIds = new Set(objectType.links.map((link) => link.id));
+  if (!linkIds.has(predicate.linkId)) {
+    throw new RuleValidationError(`Rule "${rule.id}": unknown link "${predicate.linkId}" on object type "${objectType.id}".`);
+  }
+}
+
+// src/rules/builders.ts
+function assertNonEmpty(value, field) {
+  if (!value.trim()) {
+    throw new RuleValidationError(`Rule ${field} must not be empty.`);
+  }
+}
+function createPropertyPredicateBuilder2(propertyId) {
+  return createPropertyPredicateBuilder(propertyId, {
+    subject: "Rule",
+    createError: (message) => new RuleValidationError(message)
+  });
+}
+function createLinkPredicateBuilder2(linkId) {
+  return createLinkPredicateBuilder(linkId);
+}
+function createRuleSubjectBuilder(objectType) {
+  const properties = Object.fromEntries(objectType.properties.map((property) => [
+    property.id,
+    createPropertyPredicateBuilder2(property.id)
+  ]));
+  const links = Object.fromEntries(objectType.links.map((link) => [link.id, createLinkPredicateBuilder2(link.id)]));
+  return {
+    p: properties,
+    l: links,
+    all(...predicates) {
+      return allPredicates(predicates);
+    },
+    any(...predicates) {
+      return anyPredicates(predicates);
+    },
+    not(predicate) {
+      return notPredicate(predicate);
+    }
+  };
+}
+function defineRule(id) {
+  assertNonEmpty(id, "id");
+  const builder = {
+    on(objectType) {
+      return {
+        where(callback) {
+          const predicate = callback(createRuleSubjectBuilder(objectType));
+          assertRulePredicateShape(predicate);
+          return {
+            kind: "rule",
+            id,
+            subject: {
+              kind: "object",
+              objectTypeId: objectType.id
+            },
+            predicate
+          };
+        }
+      };
+    }
+  };
+  return builder;
+}
+// src/bootstrap/discovery.ts
+var moduleExtensions = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+async function discoverOntologySources(projectRoot) {
+  const ontologyDir = join(projectRoot, "ontology");
+  const modulePaths = await listModuleFiles(ontologyDir);
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: "ontology"
+  });
+  const ontologyDocuments = [];
+  const objectTypes = [];
+  const valueTypes = [];
+  for (const candidate of exportedCandidates) {
+    if (isOntologyDocumentInput(candidate)) {
+      ontologyDocuments.push(candidate);
+      continue;
+    }
+    if (isObjectTypeWithPropertyTokens(candidate)) {
+      objectTypes.push(candidate);
+      continue;
+    }
+    if (isValueType(candidate)) {
+      valueTypes.push(candidate);
+    }
+  }
+  const discoveredSources = [...ontologyDocuments, ...objectTypes];
+  if (valueTypes.length > 0) {
+    discoveredSources.push({
+      id: "__sixb.discovered.value-types__",
+      version: "0.0.0",
+      objectTypes: [],
+      valueTypes
+    });
+  }
+  return discoveredSources;
+}
+var definitionDiscoveryRegistry = {
+  actions: { directory: ["actions"], kind: "action", isDefinition: isActionDefinition },
+  projections: {
+    directory: ["projections"],
+    kind: "projection",
+    isDefinition: isProjectionDefinition
+  },
+  schedules: {
+    directory: ["schedules"],
+    kind: "schedule",
+    isDefinition: isScheduleDefinition
+  },
+  syncs: { directory: ["syncs"], kind: "sync", isDefinition: isSyncDefinition },
+  connectors: {
+    directory: ["connectors"],
+    kind: "connector",
+    isDefinition: isConnectorDefinition
+  },
+  pipelines: {
+    directory: ["pipelines"],
+    kind: "pipeline",
+    isDefinition: isPipelineDefinition
+  },
+  datasets: { directory: ["datasets"], kind: "dataset", isDefinition: isDatasetDefinition },
+  rules: { directory: ["rules"], kind: "rule", isDefinition: isRuleDefinition },
+  workflows: {
+    directory: ["workflows"],
+    kind: "workflow",
+    isDefinition: isWorkflowDefinition
+  },
+  groups: {
+    directory: ["security", "groups"],
+    kind: "group",
+    isDefinition: isGroupDefinition
+  },
+  roles: {
+    directory: ["security", "roles"],
+    kind: "role",
+    isDefinition: isRoleDefinition
+  },
+  membershipPolicies: {
+    directory: ["security", "policies"],
+    kind: "membershipPolicy",
+    isDefinition: isMembershipPolicyDefinition
+  },
+  agents: { directory: ["agents"], kind: "agent", isDefinition: isAgentDefinition }
+};
+async function discoverProjectDefinitions(projectRoot) {
+  const entries = await Promise.all(Object.entries(definitionDiscoveryRegistry).map(async ([key, family]) => {
+    const definitions = await discoverDefinitionFamily(projectRoot, family);
+    return [key, definitions];
+  }));
+  return Object.fromEntries(entries);
+}
+async function discoverDefinitionFamily(projectRoot, family) {
+  const modulePaths = await listModuleFiles(join(projectRoot, ...family.directory));
+  const exportedCandidates = await loadModuleExports({
+    modulePaths,
+    projectRoot,
+    kind: family.kind
+  });
+  return exportedCandidates.filter(family.isDefinition);
+}
+async function loadModuleExports(options) {
+  const exportedCandidates = [];
+  const seen = new Set;
+  for (const modulePath of options.modulePaths) {
+    let moduleNamespace;
+    try {
+      moduleNamespace = await import(pathToFileURL(modulePath).href);
+    } catch (error) {
+      const relPath = relative(options.projectRoot, modulePath);
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new RuntimeError(`Failed to load ${options.kind} module '${relPath}': ${reason}`);
+    }
+    for (const exportedValue of Object.values(moduleNamespace)) {
+      collectExportedCandidates(exportedValue, exportedCandidates, seen);
+    }
+  }
+  return exportedCandidates;
+}
+function collectExportedCandidates(value, target, seen) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectExportedCandidates(item, target, seen);
+    }
+    return;
+  }
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value === "object" && value !== null || typeof value === "function") {
+    if (seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+  }
+  target.push(value);
+}
+async function listModuleFiles(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const files = [];
+  const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sortedEntries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listModuleFiles(fullPath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!hasSupportedModuleExtension(entry.name)) {
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files;
+}
+function isNotFoundError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function hasSupportedModuleExtension(fileName) {
+  const normalized = fileName.toLowerCase();
+  for (const extension of moduleExtensions) {
+    if (normalized.endsWith(extension)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOntologyDocumentInput(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.version === "string" && Array.isArray(value.objectTypes);
+}
+function isObjectTypeWithPropertyTokens(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && Array.isArray(value.properties) && Array.isArray(value.links) && isRecord2(value.p);
+}
+function isValueType(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.name === "string" && "schema" in value && !Array.isArray(value.properties) && !Array.isArray(value.objectTypes);
+}
+// src/bootstrap/ontology-type-manifest.ts
+import { mkdir, readdir as readdir2, readFile, writeFile } from "fs/promises";
+import { dirname, extname, join as join2, relative as relative2, resolve, sep } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var moduleExtensions2 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+async function discoverOntologyTypeManifest(projectRoot) {
+  const resolvedProjectRoot = resolve(projectRoot);
+  const ontologyDir = join2(resolvedProjectRoot, "ontology");
+  const modulePaths = await listModuleFiles2(ontologyDir);
+  const entries = new Map;
+  const seenObjectTypes = new Set;
+  for (const modulePath of modulePaths) {
+    const moduleSpecifier = toGeneratedModuleSpecifier({
+      fromDir: join2(resolvedProjectRoot, ".sixb", "types"),
+      modulePath
+    });
+    const moduleNamespace = await loadOntologyModule({
+      modulePath,
+      projectRoot: resolvedProjectRoot
+    });
+    for (const [exportName, exportedValue] of Object.entries(moduleNamespace)) {
+      collectManifestEntries({
+        exportedValue,
+        exportName,
+        modulePath,
+        moduleSpecifier,
+        entries,
+        seenObjectTypes
+      });
+    }
+  }
+  return {
+    entries: [...entries.values()].sort((a, b) => a.objectTypeId.localeCompare(b.objectTypeId)),
+    moduleCount: modulePaths.length
+  };
+}
+async function generateOntologyTypeManifest(options) {
+  const projectRoot = resolve(options.projectRoot);
+  const outFile = resolve(projectRoot, options.outFile ?? join2(".sixb", "types", "ontology.d.ts"));
+  const discovery = await discoverOntologyTypeManifest(projectRoot);
+  if (discovery.moduleCount === 0) {
+    return {
+      ...discovery,
+      path: outFile,
+      written: false,
+      skipped: true
+    };
+  }
+  const content = renderOntologyTypeManifest(discovery.entries);
+  await mkdir(dirname(outFile), { recursive: true });
+  const written = await writeFileIfChanged(outFile, content);
+  return {
+    ...discovery,
+    path: outFile,
+    written,
+    skipped: false
+  };
+}
+function collectManifestEntries(input) {
+  if (isObjectTypeWithPropertyTokens2(input.exportedValue)) {
+    addManifestEntry({
+      objectType: input.exportedValue,
+      modulePath: input.modulePath,
+      exportName: input.exportName,
+      typeExpression: `typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}]`,
+      entries: input.entries,
+      seenObjectTypes: input.seenObjectTypes
+    });
+    return;
+  }
+  if (isOntologyDocumentInput2(input.exportedValue)) {
+    for (const objectType of input.exportedValue.objectTypes) {
+      addManifestEntry({
+        objectType,
+        modulePath: input.modulePath,
+        exportName: input.exportName,
+        typeExpression: `Extract<(typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}])["objectTypes"][number], { id: ${JSON.stringify(objectType.id)} }>`,
+        entries: input.entries,
+        seenObjectTypes: input.seenObjectTypes
+      });
+    }
+    return;
+  }
+  if (Array.isArray(input.exportedValue)) {
+    for (const item of input.exportedValue) {
+      if (!isObjectTypeWithPropertyTokens2(item))
+        continue;
+      addManifestEntry({
+        objectType: item,
+        modulePath: input.modulePath,
+        exportName: input.exportName,
+        typeExpression: `Extract<(typeof import(${JSON.stringify(input.moduleSpecifier)})[${JSON.stringify(input.exportName)}])[number], { id: ${JSON.stringify(item.id)} }>`,
+        entries: input.entries,
+        seenObjectTypes: input.seenObjectTypes
+      });
+    }
+  }
+}
+function addManifestEntry(input) {
+  if (input.seenObjectTypes.has(input.objectType)) {
+    return;
+  }
+  input.seenObjectTypes.add(input.objectType);
+  const existing = input.entries.get(input.objectType.id);
+  const entry = {
+    objectTypeId: input.objectType.id,
+    modulePath: input.modulePath,
+    exportName: input.exportName,
+    typeExpression: input.typeExpression
+  };
+  if (!existing) {
+    input.entries.set(input.objectType.id, entry);
+    return;
+  }
+  throw new RuntimeError(`[Sixb] Duplicate ontology object type id "${input.objectType.id}" while generating `.concat(`the type manifest: ${relative2(process.cwd(), existing.modulePath)} and `, `${relative2(process.cwd(), input.modulePath)}.`));
+}
+function renderOntologyTypeManifest(entries) {
+  const lines = [
+    "// This file is auto-generated by Sixb.",
+    "// Do not edit this file directly.",
+    "",
+    'declare module "@sixb/core/ontology" {',
+    "  interface SixbObjectTypeMap {"
+  ];
+  for (const entry of entries) {
+    lines.push(`    ${JSON.stringify(entry.objectTypeId)}: ${entry.typeExpression}`);
+  }
+  lines.push("  }", "}", "", "export {}", "");
+  return lines.join(`
+`);
+}
+async function writeFileIfChanged(path, content) {
+  try {
+    const existing = await readFile(path, "utf-8");
+    if (existing === content)
+      return false;
+  } catch (error) {
+    if (!isNotFoundError2(error))
+      throw error;
+  }
+  await writeFile(path, content, "utf-8");
+  return true;
+}
+async function loadOntologyModule(input) {
+  try {
+    return await import(pathToFileURL2(input.modulePath).href);
+  } catch (error) {
+    const relPath = relative2(input.projectRoot, input.modulePath);
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new RuntimeError(`Failed to load ontology module '${relPath}': ${reason}`);
+  }
+}
+async function listModuleFiles2(dir) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const files = [];
+  const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sortedEntries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listModuleFiles2(fullPath));
+      continue;
+    }
+    if (!entry.isFile() || !hasSupportedModuleExtension2(entry.name)) {
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files;
+}
+function toGeneratedModuleSpecifier(input) {
+  const withoutExtension = stripSupportedModuleExtension(input.modulePath);
+  const relativePath = relative2(input.fromDir, withoutExtension).split(sep).join("/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function stripSupportedModuleExtension(path) {
+  const extension = extname(path);
+  return moduleExtensions2.has(extension) ? path.slice(0, -extension.length) : path;
+}
+function hasSupportedModuleExtension2(fileName) {
+  return moduleExtensions2.has(extname(fileName).toLowerCase());
+}
+function isNotFoundError2(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isObjectTypeWithPropertyTokens2(value) {
+  if (!isRecord3(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && Array.isArray(value.properties) && Array.isArray(value.links) && isRecord3(value.p);
+}
+function isOntologyDocumentInput2(value) {
+  if (!isRecord3(value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.version === "string" && Array.isArray(value.objectTypes);
+}
+export { RuleValidationError, isRuleDefinition, validateRulesAtStartup, defineRule, discoverOntologySources, discoverProjectDefinitions, discoverOntologyTypeManifest, generateOntologyTypeManifest };
+
+//# debugId=2CA9617BCA37783A64756E2164756E21