@frontal-labs/ontology 0.0.1

package/dist/index.mjs

@@ -0,0 +1,434 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import { FrontalClient, getDefaultClient, HttpClient } from "@frontal-labs/core";
+
+// src/service.ts
+import {
+  createPageResult
+} from "@frontal-labs/core";
+
+// src/schemas.ts
+import { timestampSchema } from "@frontal-labs/core";
+import { z } from "zod";
+var FieldTypeSchema = z.enum([
+  "string",
+  "integer",
+  "float",
+  "boolean",
+  "uuid",
+  "timestamp",
+  "currency",
+  "json",
+  "array",
+  "enum",
+  "vector",
+  "text"
+]);
+var RelationshipTypeSchema = z.enum([
+  "hasOne",
+  "hasMany",
+  "belongsTo",
+  "manyToMany"
+]);
+var FieldDefinitionSchema = z.object({
+  type: FieldTypeSchema,
+  required: z.boolean().default(false),
+  primary: z.boolean().default(false),
+  unique: z.boolean().default(false),
+  default: z.unknown().optional(),
+  substrate: z.string().optional(),
+  computed: z.boolean().optional(),
+  derivedBy: z.string().optional(),
+  cache: z.object({
+    ttl: z.string()
+  }).optional(),
+  auto: z.boolean().optional(),
+  enum: z.array(z.string()).optional(),
+  dimensions: z.number().int().optional(),
+  items: z.string().optional(),
+  description: z.string().optional()
+}).passthrough();
+var RelationshipDefinitionSchema = z.object({
+  name: z.string().optional(),
+  type: RelationshipTypeSchema,
+  targetEntity: z.string(),
+  foreignKey: z.string().optional(),
+  substrate: z.string().optional(),
+  cascade: z.object({
+    delete: z.enum(["hard", "soft", "restrict", "nullify"]),
+    update: z.enum(["cascade", "restrict"])
+  }).optional(),
+  computed: z.record(z.string(), z.unknown()).optional(),
+  description: z.string().optional()
+}).passthrough();
+var SubstrateRoutingSchema = z.object({
+  operational: z.string().optional(),
+  analytical: z.string().optional(),
+  semantic: z.string().optional(),
+  cache: z.string().optional()
+}).passthrough();
+var SemanticMetadataSchema = z.object({
+  description: z.string().optional(),
+  lifecycle: z.array(z.string()).optional(),
+  criticalFields: z.array(z.string()).optional(),
+  significantEvents: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional()
+}).passthrough();
+var IndexDefinitionSchema = z.object({
+  name: z.string().optional(),
+  fields: z.array(z.string()).min(1),
+  substrate: z.string().optional(),
+  unique: z.boolean().default(false),
+  type: z.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
+}).passthrough();
+var ModelDefinitionSchema = z.object({
+  name: z.string(),
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  extends: z.string().optional(),
+  mixins: z.array(z.string()).optional(),
+  fields: z.record(z.string(), FieldDefinitionSchema),
+  relationships: z.record(z.string(), RelationshipDefinitionSchema).optional(),
+  substrates: SubstrateRoutingSchema.optional(),
+  semantics: SemanticMetadataSchema.optional(),
+  indexes: z.array(IndexDefinitionSchema).optional(),
+  status: z.enum(["draft", "active", "deprecated"]).default("draft")
+}).strict();
+var ModelSchema = ModelDefinitionSchema.extend({
+  id: z.string(),
+  version: z.number().int(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  entityCount: z.number().int().optional()
+}).passthrough();
+var MigrationPlanSchema = z.object({
+  id: z.string(),
+  modelId: z.string(),
+  fromVersion: z.number().int(),
+  toVersion: z.number().int(),
+  changes: z.array(
+    z.object({
+      type: z.enum([
+        "add-field",
+        "remove-field",
+        "modify-field",
+        "add-relationship",
+        "remove-relationship"
+      ]),
+      description: z.string(),
+      impact: z.enum(["breaking", "non-breaking", "data-loss"]),
+      sql: z.string().optional()
+    })
+  ),
+  riskLevel: z.enum(["low", "medium", "high", "critical"]),
+  estimatedDowntime: z.string().optional(),
+  rolloutStrategy: z.enum([
+    "zero-downtime",
+    "maintenance-window",
+    "immediate"
+  ]),
+  createdAt: timestampSchema
+}).passthrough();
+var RuleDefinitionSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  entityTypes: z.array(z.string()).min(1),
+  condition: z.string(),
+  action: z.enum(["validate", "transform", "notify"]),
+  severity: z.enum(["error", "warning", "info"]),
+  enabled: z.boolean().default(true)
+}).strict();
+var MixinDefinitionSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  fields: z.record(z.string(), FieldDefinitionSchema),
+  relationships: z.record(z.string(), RelationshipDefinitionSchema).optional(),
+  appliesTo: z.array(z.string()).optional()
+}).strict();
+
+// src/service.ts
+var asPagePayload = (raw) => raw;
+var OntologyService = class {
+  constructor(http) {
+    this.http = http;
+    this.migrations = new MigrationsNamespace(this.http);
+    this.rules = new RulesNamespace(this.http);
+    this.mixins = new MixinsNamespace(this.http);
+    this.generation = new GenerationNamespace(this.http);
+  }
+  use(name) {
+    return new ModelAccessor(name, this.http);
+  }
+  list() {
+    return __async(this, arguments, function* (opts = {}) {
+      const raw = yield this.http.get("/ontology/engine/runs", opts);
+      return createPageResult(
+        asPagePayload(raw),
+        (cursor) => this.list(__spreadProps(__spreadValues({}, opts), { cursor }))
+      );
+    });
+  }
+  create(definition) {
+    return __async(this, null, function* () {
+      const body = ModelDefinitionSchema.parse(definition);
+      return this.http.post("/ontology/engine/runs", body);
+    });
+  }
+  validate(definition) {
+    return __async(this, null, function* () {
+      const body = ModelDefinitionSchema.parse(definition);
+      return this.http.post("/ontology/engine/ontologies/validate", body);
+    });
+  }
+  checkIntegrity() {
+    return __async(this, null, function* () {
+      return this.http.get("/ontology/engine/health");
+    });
+  }
+};
+var ModelAccessor = class {
+  constructor(_name, http) {
+    this._name = _name;
+    this.http = http;
+  }
+  get(version) {
+    return __async(this, null, function* () {
+      const params = version ? { version } : void 0;
+      return this.http.get("/ontology/engine/runs", params);
+    });
+  }
+  update(definition) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs", definition);
+    });
+  }
+  delete(force = false) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs", {
+        action: "delete-model",
+        force
+      });
+    });
+  }
+  relationships() {
+    return __async(this, null, function* () {
+      return this.http.get("/ontology/engine/runs");
+    });
+  }
+  addRelationship(definition) {
+    return __async(this, null, function* () {
+      const body = RelationshipDefinitionSchema.parse(definition);
+      return this.http.post("/ontology/engine/runs", body);
+    });
+  }
+  removeRelationship(relationshipId) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs", {
+        action: "delete-relationship",
+        relationshipId
+      });
+    });
+  }
+  validateData() {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/ontologies/validate");
+    });
+  }
+  versions() {
+    return __async(this, null, function* () {
+      return this.http.get("/ontology/engine/runs");
+    });
+  }
+};
+var MigrationsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  plan(request) {
+    return __async(this, null, function* () {
+      return this.http.post(
+        "/ontology/engine/ontologies/compare-versions",
+        request
+      );
+    });
+  }
+  apply(planId, strategy = "zero-downtime") {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs", { planId, strategy });
+    });
+  }
+  rollback(_migrationId) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs");
+    });
+  }
+  history() {
+    return __async(this, arguments, function* (opts = {}) {
+      const raw = yield this.http.get("/ontology/engine/runs", opts);
+      return createPageResult(
+        asPagePayload(raw),
+        (cursor) => this.history(__spreadProps(__spreadValues({}, opts), { cursor }))
+      );
+    });
+  }
+};
+var RulesNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list() {
+    return __async(this, null, function* () {
+      return this.http.get("/ontology/engine/runs");
+    });
+  }
+  create(definition) {
+    return __async(this, null, function* () {
+      const body = RuleDefinitionSchema.parse(definition);
+      return this.http.post("/ontology/engine/runs", body);
+    });
+  }
+  update(_ruleId, definition) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs", definition);
+    });
+  }
+  delete(ruleId) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs", {
+        action: "delete-rule",
+        ruleId
+      });
+    });
+  }
+  evaluate(opts) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/ontologies/validate", opts);
+    });
+  }
+};
+var MixinsNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  list() {
+    return __async(this, null, function* () {
+      return this.http.get("/ontology/engine/runs");
+    });
+  }
+  create(definition) {
+    return __async(this, null, function* () {
+      const body = MixinDefinitionSchema.parse(definition);
+      return this.http.post("/ontology/engine/runs", body);
+    });
+  }
+};
+var GenerationNamespace = class {
+  constructor(http) {
+    this.http = http;
+  }
+  generate(description, opts) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/ontologies/generate", __spreadValues({
+        description
+      }, opts));
+    });
+  }
+  infer(opts) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/ontologies/infer-classes", opts);
+    });
+  }
+  suggestions() {
+    return __async(this, arguments, function* (opts = {}) {
+      return this.http.get("/ontology/engine/runs", opts);
+    });
+  }
+  acceptSuggestion(_suggestionId) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs");
+    });
+  }
+  rejectSuggestion(_suggestionId, reason) {
+    return __async(this, null, function* () {
+      return this.http.post("/ontology/engine/runs", {
+        reason
+      });
+    });
+  }
+};
+
+// src/index.ts
+function createOntologyClient(clientOrConfig) {
+  var _a, _b, _c, _d, _e;
+  if (clientOrConfig instanceof FrontalClient) {
+    return new OntologyService(clientOrConfig._http);
+  }
+  const http = new HttpClient({
+    apiKey: clientOrConfig.apiKey,
+    baseUrl: (_c = (_b = (_a = clientOrConfig.baseUrl) != null ? _a : process.env.FRONTAL_ONTOLOGY_API_URL) != null ? _b : process.env.FRONTAL_API_URL) != null ? _c : "https://api.frontal.dev/v1",
+    timeout: (_d = clientOrConfig.timeout) != null ? _d : 3e4,
+    maxRetries: (_e = clientOrConfig.maxRetries) != null ? _e : 3,
+    retryDelay: 1e3,
+    headers: {},
+    environment: "production",
+    debug: false
+  });
+  return new OntologyService(http);
+}
+var ontology = new OntologyService(getDefaultClient()._http);
+export {
+  FieldDefinitionSchema,
+  FieldTypeSchema,
+  IndexDefinitionSchema,
+  MigrationPlanSchema,
+  MixinDefinitionSchema,
+  ModelDefinitionSchema,
+  ModelSchema,
+  OntologyService,
+  RelationshipDefinitionSchema,
+  RelationshipTypeSchema,
+  RuleDefinitionSchema,
+  SemanticMetadataSchema,
+  SubstrateRoutingSchema,
+  createOntologyClient,
+  ontology
+};

package/dist/keys.d.ts

@@ -0,0 +1,6 @@
+export declare const env: Readonly<{
+    FRONTAL_API_URL?: string | undefined;
+    FRONTAL_API_KEY?: string | undefined;
+    NODE_ENV: "production" | "development" | "test";
+}>;
+//# sourceMappingURL=keys.d.ts.map

package/dist/keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG;;;;EAyBd,CAAC"}