@osdk/vite-plugin-oac 0.1.0-beta.0 → 0.1.0-beta.1

package/build/cjs/index.cjs

@@ -1,14 +1,18 @@
 'use strict';
 
-var path2 = require('path');
+var fs = require('fs');
+var generatorConverters_ontologyir = require('@osdk/generator-converters.ontologyir');
+var execa = require('execa');
+var path = require('path');
+var util = require('util');
+var crypto2 = require('crypto');
 var faux = require('@osdk/faux');
+var chalk = require('chalk');
 var EventEmitter = require('events');
 var jiti = require('jiti');
+var invariant = require('tiny-invariant');
+var Emittery = require('emittery');
 var stream = require('stream');
-var fs2 = require('fs');
-var generatorConverters_ontologyir = require('@osdk/generator-converters.ontologyir');
-var execa = require('execa');
-var crypto2 = require('crypto');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -31,265 +35,24 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path2__default = /*#__PURE__*/_interopDefault(path2);
-var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
-var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var util__namespace = /*#__PURE__*/_interopNamespace(util);
 var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+var invariant__default = /*#__PURE__*/_interopDefault(invariant);
+var Emittery__default = /*#__PURE__*/_interopDefault(Emittery);
 
-// src/index.ts
-async function applySeed(fauxFoundry, seedPath) {
-  const jiti$1 = jiti.createJiti(undefined, {
-    moduleCache: false,
-    debug: false,
-    importMeta: ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) })
-  });
-  const module = await jiti$1.import(seedPath);
-  module.default(fauxFoundry);
-}
-
-// src/registerOntologyFullMetadata.ts
-function registerOntologyFullMetadata(ontology, ontologyFullMetadata) {
-  Object.values(ontologyFullMetadata.objectTypes).forEach((objectType) => {
-    ontology.registerObjectType(objectType);
-  });
-  Object.values(ontologyFullMetadata.actionTypes).forEach((actionType) => {
-    const implementation = createActionImplementation(actionType);
-    const actionTypeWithCamelCaseApiName = {
-      ...actionType,
-      apiName: camelcase(actionType.apiName)
-    };
-    ontology.registerActionType(actionTypeWithCamelCaseApiName, implementation);
-  });
-  Object.values(ontologyFullMetadata.sharedPropertyTypes).forEach((actionType) => {
-    ontology.registerSharedPropertyType(actionType);
-  });
-  Object.values(ontologyFullMetadata.queryTypes).forEach((query) => {
-    ontology.registerQueryType(query);
-  });
-  Object.values(ontologyFullMetadata.interfaceTypes).forEach((iface) => {
-    ontology.registerInterfaceType(iface);
-  });
-}
-function createActionImplementation(actionType) {
-  return (batch, payload, _ctx) => {
-    const params = payload.parameters;
-    for (const operation of actionType.operations) {
-      switch (operation.type) {
-        case "createObject": {
-          const objectTypeApiName = operation.objectTypeApiName;
-          const primaryKey = params.primaryKey_;
-          const objectData = {};
-          for (const [key, value] of Object.entries(params)) {
-            if (key !== "primaryKey_") {
-              const param = actionType.parameters[key];
-              objectData[key] = toDataValue(value, param);
-            }
-          }
-          batch.addObject(objectTypeApiName, primaryKey, objectData);
-          break;
-        }
-        case "modifyObject": {
-          let objectTypeApiName;
-          let primaryKey;
-          if (typeof operation.objectTypeApiName === "string") {
-            objectTypeApiName = operation.objectTypeApiName;
-            primaryKey = params.primaryKey_;
-          } else {
-            const objectToModify = params[operation.objectTypeApiName];
-            if (objectToModify) {
-              objectTypeApiName = objectToModify.objectTypeApiName || objectToModify;
-              primaryKey = objectToModify.primaryKeyValue || params.primaryKey_;
-            } else {
-              objectTypeApiName = operation.objectTypeApiName;
-              primaryKey = params.primaryKey_;
-            }
-          }
-          const objectData = {};
-          for (const [key, value] of Object.entries(params)) {
-            if (key !== "primaryKey_" && key !== "objectToModifyParameter") {
-              const param = actionType.parameters[key];
-              objectData[key] = toDataValue(value, param);
-            }
-          }
-          batch.modifyObject(objectTypeApiName, primaryKey, objectData);
-          break;
-        }
-        case "deleteObject": {
-          let objectTypeApiName;
-          let primaryKey;
-          if (typeof operation.objectTypeApiName === "string") {
-            objectTypeApiName = operation.objectTypeApiName;
-            primaryKey = params.primaryKey_;
-          } else {
-            const objectToDelete = params[operation.objectTypeApiName];
-            if (objectToDelete) {
-              objectTypeApiName = objectToDelete.objectTypeApiName || objectToDelete;
-              primaryKey = objectToDelete.primaryKeyValue || params.primaryKey_;
-            } else {
-              objectTypeApiName = operation.objectTypeApiName;
-              primaryKey = params.primaryKey_;
-            }
-          }
-          batch.deleteObject(objectTypeApiName, primaryKey);
-          break;
-        }
-        case "createLink": {
-          const aSideObjectTypeApiName = operation.aSideObjectTypeApiName;
-          const bSideObjectTypeApiName = operation.bSideObjectTypeApiName;
-          const linkTypeApiNameAtoB = operation.linkTypeApiNameAtoB;
-          const aSidePrimaryKey = params.aSidePrimaryKey || params.primaryKey_;
-          const bSidePrimaryKey = params.bSidePrimaryKey || params.linkedObjectPrimaryKey;
-          if (aSidePrimaryKey && bSidePrimaryKey) {
-            batch.addLink(aSideObjectTypeApiName, aSidePrimaryKey, linkTypeApiNameAtoB, bSideObjectTypeApiName, bSidePrimaryKey);
-          }
-          break;
-        }
-        case "deleteLink": {
-          const aSideObjectTypeApiName = operation.aSideObjectTypeApiName;
-          const bSideObjectTypeApiName = operation.bSideObjectTypeApiName;
-          const linkTypeApiNameAtoB = operation.linkTypeApiNameAtoB;
-          const aSidePrimaryKey = params.aSidePrimaryKey || params.primaryKey_;
-          const bSidePrimaryKey = params.bSidePrimaryKey || params.linkedObjectPrimaryKey;
-          if (aSidePrimaryKey && bSidePrimaryKey) {
-            batch.removeLink(aSideObjectTypeApiName, aSidePrimaryKey, linkTypeApiNameAtoB, bSideObjectTypeApiName, bSidePrimaryKey);
-          }
-          break;
-        }
-        // Handle other operation types as needed
-        case "createInterfaceObject":
-        case "modifyInterfaceObject":
-        case "deleteInterfaceObject":
-          throw new Error(`Operation type ${operation.type} not implemented yet`);
-        default:
-          throw new Error(`Unknown operation type: ${operation.type}`);
-      }
-    }
-  };
-}
-function camelcase(apiName) {
-  return apiName.toLowerCase().replace(/[-_]+(.)?/g, (_, chr) => chr ? chr.toUpperCase() : "");
-}
-function toDataValue(value, param) {
-  if (param.dataType.type === "geoshape" && typeof value === "string") {
-    return latLonStringToGeoJSON(value);
-  }
-  return value;
-}
-function latLonStringToGeoJSON(latLonStr) {
-  const [lat, lon] = latLonStr.split(",").map(Number);
-  if (isNaN(lat) || isNaN(lon) || lat < -90 || lat > 90 || lon < -180 || lon > 180) {
-    throw new Error("Invalid latitude or longitude");
-  }
-  return {
-    type: "Point",
-    coordinates: [lon, lat]
-    // GeoJSON uses [longitude, latitude]
-  };
-}
-async function routeConnectToMsw(baseUrl, handlers, emitter, req, res, next) {
-  const method = req.method ?? "GET";
-  const canRequestHaveBody = method !== "HEAD" && method !== "GET";
-  const mockRequest = new Request(new URL(req.url, baseUrl), {
-    method,
-    headers: new Headers(req.headers),
-    credentials: "omit",
-    // @ts-expect-error Internal Undici property.
-    duplex: canRequestHaveBody ? "half" : void 0,
-    body: canRequestHaveBody ? stream.Readable.toWeb(req) : void 0
-  });
-  await faux.msw.handleRequest(mockRequest, crypto.randomUUID(), handlers, {
-    onUnhandledRequest: "bypass"
-  }, emitter, {
-    resolutionContext: {
-      baseUrl
-    },
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async onMockedResponse(mockedResponse) {
-      const {
-        status,
-        statusText,
-        headers
-      } = mockedResponse;
-      res.statusCode = status;
-      res.statusMessage = statusText;
-      headers.forEach((value, name) => {
-        res.appendHeader(name, value);
-      });
-      if (mockedResponse.body) {
-        const stream$1 = stream.Readable.fromWeb(mockedResponse.body);
-        stream$1.pipe(res);
-      } else {
-        res.end();
-      }
-    },
-    onPassthroughResponse() {
-      next();
-    }
-  });
-}
-function readJsonFile(arg0) {
-  const content = fs2__namespace.readFileSync(arg0, "utf-8");
-  return JSON.parse(content);
-}
-
-// src/FoundryMiddlewareController.ts
-var FoundryMiddlewareController = class {
-  #fauxFoundry;
-  #serverUrl;
-  #defaultOntologyRid;
-  mswEmitter = new EventEmitter__default.default();
-  #hooks;
-  constructor(serverUrl, defaultOntologyRid, oacEmitter, hooks) {
-    this.#serverUrl = serverUrl;
-    this.#defaultOntologyRid = defaultOntologyRid;
-    this.#hooks = hooks;
-    this.#fauxFoundry = this.#createNewFauxFoundry();
-    oacEmitter.on("generated", () => {
-      this.#reloadOntologyDefinition().catch((e) => {
-        console.error("[oac] error reloading ontology definition", e);
-      });
-    });
-  }
-  #debugLog(message, ...optionalParams) {
-    console.log("[oac]", message, ...optionalParams);
+// src/OacConfig.ts
+var OacConfig = class {
+  constructor(config) {
+    Object.assign(this, config);
   }
-  #infoLog(message, ...optionalParams) {
-    console.log("[oac]", message, ...optionalParams);
-  }
-  #errorLog(message, ...optionalParams) {
-    console.error("[oac]", message, ...optionalParams);
-  }
-  #createNewFauxFoundry() {
-    return new faux.FauxFoundry(this.#serverUrl, {
-      apiName: "DefaultOntology",
-      description: "Description",
-      displayName: "Ontology",
-      rid: this.#defaultOntologyRid
-    });
-  }
-  async #reloadOntologyDefinition() {
-    const fauxFoundry = this.#fauxFoundry = this.#createNewFauxFoundry();
-    const ontology = fauxFoundry.getDefaultOntology();
-    const ontologyFullMetadata = readJsonFile(".ontology.json");
-    registerOntologyFullMetadata(ontology, ontologyFullMetadata);
-    try {
-      if (this.#hooks?.preSeed) {
-        this.#debugLog("[oac] calling preSeed hook");
-      }
-      await this.#hooks?.preSeed?.(ontology);
-    } catch (e) {
-      this.#errorLog("[oac] Unhandled error from preSeed hook. Ignoring and continuing.", e);
-    }
-    this.#debugLog("[osdk] applying seed data");
-    await applySeed(this.#fauxFoundry, path2__default.default.resolve(undefined, "..", "..", ".ontology", "seed.ts"));
-    this.#infoLog("[osdk] Finished reloading ontology & seed data");
-  }
-  middleware = async (req, res, next) => {
-    return void await routeConnectToMsw(this.#serverUrl, this.#fauxFoundry.handlers, this.mswEmitter, req, res, next);
-  };
 };
 async function syncDirectories(sourceDir, targetDir, logger) {
-  await fs2__namespace.default.promises.mkdir(targetDir, {
+  logger.debug(`Synchronizing ${sourceDir} to ${targetDir}`);
+  await fs__namespace.default.promises.mkdir(targetDir, {
     recursive: true
   });
   const [sourceFiles, targetFiles] = await Promise.all([getAllFiles(sourceDir), getAllFiles(targetDir)]);
@@ -299,84 +62,71 @@ async function syncDirectories(sourceDir, targetDir, logger) {
   let unchangedCount = 0;
   const errors = [];
   for (const relativeFile of sourceFiles) {
-    const sourceFile = path2__default.default.join(sourceDir, relativeFile);
-    const targetFile = path2__default.default.join(targetDir, relativeFile);
+    const sourceFile = path__namespace.default.join(sourceDir, relativeFile);
+    const targetFile = path__namespace.default.join(targetDir, relativeFile);
     try {
       const targetExists = targetFiles.includes(relativeFile);
       const isDifferent = await areFilesDifferent(sourceFile, targetFile);
       if (!targetExists) {
-        await fs2__namespace.default.promises.mkdir(path2__default.default.dirname(targetFile), {
+        await fs__namespace.default.promises.mkdir(path__namespace.default.dirname(targetFile), {
           recursive: true
         });
-        await fs2__namespace.default.promises.copyFile(sourceFile, targetFile);
+        await fs__namespace.default.promises.copyFile(sourceFile, targetFile);
         addedCount++;
-        logger.info(`Added: ${relativeFile}`, {
-          timestamp: true
-        });
+        logger.debug(`Added: ${relativeFile}`);
       } else if (isDifferent) {
-        await fs2__namespace.default.promises.copyFile(sourceFile, targetFile);
+        await fs__namespace.default.promises.copyFile(sourceFile, targetFile);
         updatedCount++;
-        logger.info(`Updated: ${targetFile}`, {
-          timestamp: true
-        });
+        logger.debug(`Updated: ${targetFile}`);
       } else {
         unchangedCount++;
       }
     } catch (error) {
       const errorMsg = `Failed to sync ${relativeFile}: ${error instanceof Error ? error.message : String(error)}`;
       errors.push(errorMsg);
-      logger.error(errorMsg, {
-        timestamp: true
-      });
+      logger.error(errorMsg);
     }
   }
   for (const relativeFile of targetFiles) {
     if (!sourceFiles.includes(relativeFile)) {
-      const targetFile = path2__default.default.join(targetDir, relativeFile);
+      const targetFile = path__namespace.default.join(targetDir, relativeFile);
       try {
-        await fs2__namespace.default.promises.unlink(targetFile);
+        await fs__namespace.default.promises.unlink(targetFile);
         removedCount++;
-        logger.info(`Removed: ${relativeFile}`, {
-          timestamp: true
-        });
+        logger.debug(`Removed: ${relativeFile}`);
       } catch (error) {
         const errorMsg = `Failed to remove ${relativeFile}: ${error instanceof Error ? error.message : String(error)}`;
         errors.push(errorMsg);
-        logger.error(errorMsg, {
-          timestamp: true
-        });
+        logger.error(errorMsg);
       }
     }
   }
   try {
     await removeEmptyDirectories(targetDir);
   } catch (error) {
-    logger.warn(`Failed to clean up empty directories: ${error instanceof Error ? error.message : String(error)}`, {
-      timestamp: true
-    });
+    logger.warn(`Failed to clean up empty directories: ${error instanceof Error ? error.message : String(error)}`);
   }
+  logger.debug(`Sync complete: ${addedCount} added, ${updatedCount} updated, ${removedCount} removed, ${unchangedCount} unchanged`);
   if (errors.length > 0) {
-    logger.warn(`Encountered ${errors.length} errors during sync`, {
-      timestamp: true
-    });
+    logger.warn(`Encountered ${errors.length} errors during sync`);
   }
 }
 async function removeEmptyDirectories(dir) {
   try {
-    const entries = await fs2__namespace.default.promises.readdir(dir, {
+    const entries = await fs__namespace.default.promises.readdir(dir, {
       withFileTypes: true
     });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subdir = path2__default.default.join(dir, entry.name);
+        const subdir = path__namespace.default.join(dir, entry.name);
         await removeEmptyDirectories(subdir);
       }
     }
-    const remainingEntries = await fs2__namespace.default.promises.readdir(dir);
+    const remainingEntries = await fs__namespace.default.promises.readdir(dir);
     if (remainingEntries.length === 0) {
       const targetDir = ".osdk/src";
-      if (path2__default.default.resolve(dir) !== path2__default.default.resolve(targetDir)) {
-        await fs2__namespace.default.promises.rmdir(dir);
+      if (path__namespace.default.resolve(dir) !== path__namespace.default.resolve(targetDir)) {
+        await fs__namespace.default.promises.rmdir(dir);
       }
     }
   } catch (error) {
@@ -384,7 +134,7 @@ async function removeEmptyDirectories(dir) {
 }
 async function getFileHash(filePath) {
   try {
-    const content = await fs2__namespace.default.promises.readFile(filePath);
+    const content = await fs__namespace.default.promises.readFile(filePath);
     return crypto2__default.default.createHash("sha256").update(content).digest("hex");
   } catch (error) {
     return "";
@@ -401,12 +151,12 @@ async function areFilesDifferent(sourceFile, targetFile) {
 async function getAllFiles(dir, baseDir = dir) {
   const files = [];
   try {
-    const entries = await fs2__namespace.default.promises.readdir(dir, {
+    const entries = await fs__namespace.default.promises.readdir(dir, {
       withFileTypes: true
     });
     for (const entry of entries) {
-      const fullPath = path2__default.default.join(dir, entry.name);
-      const relativePath = path2__default.default.relative(baseDir, fullPath);
+      const fullPath = path__namespace.default.join(dir, entry.name);
+      const relativePath = path__namespace.default.relative(baseDir, fullPath);
       if (entry.isDirectory()) {
         const subFiles = await getAllFiles(fullPath, baseDir);
         files.push(...subFiles);
@@ -420,203 +170,525 @@ async function getAllFiles(dir, baseDir = dir) {
 }
 
 // src/generateOntologyAssets.ts
-var NOISY = false;
-async function generateOntologyAssets({
-  logger,
-  ontologyDir
-}) {
-  if (!fs2__namespace.default.existsSync(ontologyDir)) {
-    fs2__namespace.default.mkdirSync(ontologyDir, {
+async function generateOntologyAssets(opts) {
+  const {
+    ontologyDir,
+    logger
+  } = opts;
+  await fs__namespace.promises.mkdir(opts.workDir, {
+    recursive: true
+  });
+  if (!fs__namespace.existsSync(ontologyDir)) {
+    fs__namespace.mkdirSync(ontologyDir, {
       recursive: true
     });
-    logger.info("Created .ontology directory", {
-      timestamp: true
-    });
+    logger.info("Created .ontology directory");
   }
-  await ontologyJsToIr(logger);
-  await ontologyIrToFullMetadata(logger);
-  await fullMetadataToOsdk(logger);
+  await ontologyJsToIr(opts);
+  await ontologyIrToFullMetadata(opts);
+  await fullMetadataToOsdk(opts);
 }
-async function ontologyJsToIr(logger) {
+function ontologyIrPath(workDir) {
+  return path__namespace.join(workDir, ".ontology.ir.json");
+}
+function ontologyFullMetadataPath(workDir) {
+  return path__namespace.join(workDir, ".ontology.json");
+}
+async function ontologyJsToIr({
+  logger,
+  ontologyDir,
+  workDir
+}) {
+  logger.debug("Generating Ontology IR");
   const {
     stdout,
     stderr,
     exitCode
-  } = await execa.execa("pnpm", ["exec", "maker", "-i", ".ontology/ontology.mjs", "-o", ".ontology.ir.json"]);
+  } = await execa.execa("pnpm", ["exec", "maker", "-i", `${ontologyDir}/ontology.mts`, "-o", ontologyIrPath(workDir)]);
   if (exitCode !== 0) {
-    logger.error(`Ontology IR generation failed with exit code ${exitCode}`, {
-      timestamp: true
-    });
+    logger.error(`Ontology IR generation failed with exit code ${exitCode}`);
     if (stderr) {
-      logger.error(`Command stderr: ${stderr}`, {
-        timestamp: true
-      });
+      logger.error(`Command stderr: ${stderr}`);
     }
     throw new Error(`Failed to generate ontology IR: exit code ${exitCode}`);
   }
+  if (stdout) {
+    logger.debug(`Ontology IR generation output: ${stdout}`);
+  }
 }
-async function ontologyIrToFullMetadata(logger) {
+async function ontologyIrToFullMetadata({
+  logger,
+  workDir
+}) {
+  logger.debug("Converting IR to Full metadata");
   try {
-    const irContent = await fs2__namespace.default.promises.readFile("./.ontology.ir.json", {
+    const irContent = await fs__namespace.promises.readFile(ontologyIrPath(workDir), {
       encoding: "utf-8"
     });
     const blockData = JSON.parse(irContent).blockData;
     const fullMeta = generatorConverters_ontologyir.OntologyIrToFullMetadataConverter.getFullMetadataFromIr(blockData);
-    await fs2__namespace.default.promises.writeFile("./.ontology.json", JSON.stringify(fullMeta, null, 2));
-    if (NOISY) ;
+    await fs__namespace.promises.writeFile(ontologyFullMetadataPath(workDir), JSON.stringify(fullMeta, null, 2));
+    logger.debug("Successfully converted IR to full metadata");
   } catch (error) {
-    logger.error(`Failed to convert IR to full metadata: ${error instanceof Error ? error.message : String(error)}`, {
-      timestamp: true
-    });
+    logger.error(`Failed to convert IR to full metadata: ${util.inspect(error)}`);
     throw error;
   }
 }
-async function fullMetadataToOsdk(logger) {
-  const tempDir = path2__default.default.join(process.cwd(), "node_modules", ".tmp", "osdkGeneration");
-  await fs2__namespace.default.promises.rm(tempDir, {
+async function fullMetadataToOsdk({
+  logger,
+  workDir
+}) {
+  logger.debug("Generating OSDK from full metadata");
+  const tempDir = path__namespace.join(workDir, ".osdkGenerationTmp", "src");
+  await fs__namespace.promises.rm(tempDir, {
     recursive: true,
     force: true
   });
-  await fs2__namespace.default.promises.mkdir(tempDir, {
+  await fs__namespace.promises.mkdir(tempDir, {
     recursive: true
   });
+  await fs__namespace.promises.writeFile(path__namespace.join(tempDir, "..", "package.json"), JSON.stringify({}, null, 2), {
+    encoding: "utf-8"
+  });
   try {
-    const tempSrcDir = path2__default.default.join(tempDir, "src");
+    const tempSrcDir = path__namespace.join(tempDir, "src");
     const {
       stdout,
       stderr,
       exitCode
-    } = await execa.execa("pnpm", ["exec", "osdk", "unstable", "typescript", "generate", "--outDir", tempSrcDir, "--ontologyPath", ".ontology.json", "--beta", "true", "--packageType", "module", "--version", "dev"]);
-    if (stdout && NOISY) ;
+    } = await execa.execa("pnpm", ["exec", "osdk", "unstable", "typescript", "generate", "--outDir", tempSrcDir, "--ontologyPath", ontologyFullMetadataPath(workDir), "--beta", "true", "--packageType", "module", "--version", "dev"]);
+    logger.debug(`OSDK generation output: ${stdout}`);
     if (stderr) {
-      logger.error(`OSDK generation stderr: ${stderr}`, {
-        timestamp: true
-      });
+      logger.error(`OSDK generation stderr: ${stderr}`);
     }
     if (exitCode === 0) {
       const targetDir = ".osdk/src";
       try {
-        if (NOISY) ;
+        logger.debug("OSDK generation successful, synchronizing with target directory");
         await syncDirectories(tempSrcDir, targetDir, logger);
-        if (NOISY) ;
-        await fs2__namespace.default.promises.rm(tempDir, {
+        logger.debug(`Successfully synchronized ${targetDir} with newly generated code`);
+        await compileOsdk(logger);
+        await fs__namespace.promises.rm(tempDir, {
           recursive: true,
           force: true
         });
       } catch (error) {
-        logger.error(`Failed to synchronize ${targetDir} directory: ${error instanceof Error ? error.message : String(error)}`, {
-          timestamp: true
-        });
-        logger.error(`Temporary files left at: ${tempDir}`, {
-          timestamp: true
-        });
+        logger.error(`Failed to synchronize ${targetDir} directory: ${util.inspect(error)}`);
+        logger.error(`Temporary files left at: ${tempDir}`);
         throw error;
       }
     } else {
-      logger.error(`OSDK generation failed with exit code ${exitCode}`, {
-        timestamp: true
-      });
-      logger.error(`Temporary files left at: ${tempDir}`, {
-        timestamp: true
-      });
+      logger.error(`OSDK generation failed with exit code ${exitCode}`);
+      logger.error(`Temporary files left at: ${tempDir}`);
       throw new Error(`OSDK generation failed with exit code ${exitCode}`);
     }
   } catch (error) {
     try {
-      await fs2__namespace.default.promises.rm(tempDir, {
+      await fs__namespace.promises.rm(tempDir, {
         recursive: true,
         force: true
       });
     } catch (cleanupError) {
-      logger.warn(`Failed to clean up temporary directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`, {
-        timestamp: true
-      });
+      logger.warn(`Failed to clean up temporary directory: ${util.inspect(cleanupError)}`);
     }
     throw error;
   }
 }
-function watchOntologyAsCode({
-  watcher,
-  logger,
-  ontologyDir
-}) {
-  const emitter = new EventEmitter__default.default();
-  logger.info(`Starting OAC file watcher for ${ontologyDir}`, {
-    timestamp: true
+async function compileOsdk(logger) {
+  const {
+    stdout,
+    stderr,
+    exitCode
+  } = await execa.execa("pnpm", ["exec", "tsc"], {
+    cwd: ".osdk"
   });
-  if (!fs2__namespace.default.existsSync(ontologyDir)) {
-    fs2__namespace.default.mkdirSync(ontologyDir, {
-      recursive: true
-    });
-    logger.info("Created .ontology directory", {
-      timestamp: true
-    });
+  logger.debug(`OSDK generation output: ${stdout}`);
+  if (stderr) {
+    logger.error(`OSDK generation stderr: ${stderr}`);
   }
-  watcher.add(ontologyDir);
-  watcher.on("add", handleOacFileChanged).on("change", handleOacFileChanged).on("unlink", handleOacFileChanged);
-  handleOacFileChanged(void 0);
-  return emitter;
-  function handleOacFileChanged(filePath) {
-    if (filePath && !filePath.startsWith(`${ontologyDir}/`)) {
-      return;
+  return exitCode;
+}
+var Level = /* @__PURE__ */ function(Level2) {
+  Level2[Level2["debug"] = 0] = "debug";
+  Level2[Level2["info"] = 1] = "info";
+  Level2[Level2["warn"] = 2] = "warn";
+  Level2[Level2["error"] = 3] = "error";
+  return Level2;
+}({});
+var Logger = class {
+  #level;
+  #viteLogger;
+  constructor({
+    level,
+    viteLogger
+  }) {
+    this.#level = typeof level === "string" ? Level[level] : level;
+    this.#viteLogger = viteLogger;
+  }
+  debug(message) {
+    if (this.#level <= Level.debug) {
+      this.#viteLogger.info(`${chalk__default.default.cyan("[osdk]")} ${chalk__default.default.gray(`DEBUG: ${message}`)}`, {
+        timestamp: true
+      });
     }
-    if (filePath) {
-      logger.info(`File ${filePath} changed.`, {
+  }
+  info(message) {
+    if (this.#level <= Level.info) {
+      this.#viteLogger.info(`${chalk__default.default.cyan("[osdk]")} ${message}`, {
         timestamp: true
       });
     }
-    (async () => {
-      await generateOntologyAssets({
-        logger,
-        ontologyDir
+  }
+  error(message) {
+    if (this.#level <= Level.error) {
+      this.#viteLogger.error(`${chalk__default.default.cyan("[osdk]")} ${chalk__default.default.red(message)}`, {
+        timestamp: true
       });
-      emitter.emit("generated");
-    })().catch((error) => {
-      console.error(error);
-      logger.error(`Error executing command: ${error.message}`, {
+    }
+  }
+  warn(message) {
+    if (this.#level <= Level.warn) {
+      this.#viteLogger.warn(`${chalk__default.default.cyan("[osdk]")} ${chalk__default.default.yellow(message)}`, {
         timestamp: true
       });
+    }
+  }
+};
+
+// src/OacContext.ts
+var OacContext = class extends OacConfig {
+  constructor(config, resolvedConfig) {
+    super(config);
+    this.serverUrl = `http${resolvedConfig.server.https ? "s" : ""}://localhost:${resolvedConfig.server.port}`;
+    this.defaultOntologyRid = `ri.ontology.main.ontology.00000000-0000-0000-0000-000000000000`;
+    this.workDir = path__namespace.join("node_modules", ".osdk", ".oac");
+    this.logger = new Logger({
+      level: config.loggerLevel ?? Level.info,
+      viteLogger: resolvedConfig.logger
     });
+    this.workDir = path__namespace.join("node_modules", ".osdk", ".oac");
   }
+  fauxFoundryFactory = () => {
+    return new faux.FauxFoundry(this.serverUrl, {
+      apiName: "DefaultOntology",
+      description: "Description",
+      displayName: "Ontology",
+      rid: this.defaultOntologyRid
+    });
+  };
+};
+async function applySeed(fauxFoundry, seedPath) {
+  const jiti$1 = jiti.createJiti(undefined, {
+    moduleCache: false,
+    debug: false,
+    importMeta: ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) })
+  });
+  const module = await jiti$1.import(seedPath);
+  module.default(fauxFoundry);
 }
-
-// src/index.ts
-function ontologyAsCode(opts) {
-  const ontologyDir = path2__default.default.resolve(".ontology");
-  let config;
+util.inspect.defaultOptions = {
+  colors: true,
+  depth: Infinity
+};
+function registerOntologyFullMetadata(ontology, ontologyFullMetadata) {
+  Object.values(ontologyFullMetadata.objectTypes).forEach((objectType) => {
+    ontology.registerObjectType(objectType);
+  });
+  Object.values(ontologyFullMetadata.actionTypes).forEach((actionType) => {
+    const implementation = createActionImplementation(actionType, ontologyFullMetadata);
+    const actionTypeWithCamelCaseApiName = {
+      ...actionType,
+      apiName: camelcase(actionType.apiName)
+    };
+    ontology.registerActionType(actionTypeWithCamelCaseApiName, implementation);
+  });
+  Object.values(ontologyFullMetadata.sharedPropertyTypes).forEach((actionType) => {
+    ontology.registerSharedPropertyType(actionType);
+  });
+  Object.values(ontologyFullMetadata.queryTypes).forEach((query) => {
+    ontology.registerQueryType(query);
+  });
+  Object.values(ontologyFullMetadata.interfaceTypes).forEach((iface) => {
+    ontology.registerInterfaceType(iface);
+  });
+}
+function createActionImplementation(actionType, fullMetadata) {
+  return (batch, payload, _ctx) => {
+    const params = payload.parameters;
+    for (const operation of actionType.operations) {
+      switch (operation.type) {
+        case "createObject": {
+          const objectType = getObjectTypeForOperation(operation, fullMetadata);
+          const primaryKeyProp = objectType.objectType.primaryKey;
+          const primaryKey = extractAndDelete(params, primaryKeyProp);
+          const objectData = paramsToDataValues(params, actionType);
+          batch.addObject(objectType.objectType.apiName, primaryKey, objectData);
+          handleObjectLinks(batch, fullMetadata, objectType.objectType.apiName, primaryKey, params);
+          break;
+        }
+        case "modifyObject": {
+          const {
+            objectType
+          } = getObjectTypeForOperation(operation, fullMetadata);
+          const primaryKey = extractAndDelete(params, "objectToModifyParameter");
+          const targetObject = batch.getObject(objectType.apiName, primaryKey);
+          !targetObject ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Could not find object ${objectType.apiName} with PK ${primaryKey}`) : invariant__default.default(false) : void 0;
+          if (objectType.primaryKey in params) {
+            !(params[objectType.primaryKey] === primaryKey) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `If the primary key is provided, it must match the 'objectToModifyParameter'`) : invariant__default.default(false) : void 0;
+            delete params[objectType.primaryKey];
+          }
+          const objectData = paramsToDataValues(params, actionType);
+          batch.modifyObject(objectType.apiName, primaryKey, objectData);
+          handleObjectLinks(batch, fullMetadata, objectType.apiName, primaryKey, params);
+          break;
+        }
+        case "deleteObject": {
+          const {
+            objectType
+          } = getObjectTypeForOperation(operation, fullMetadata);
+          const primaryKey = extractAndDelete(params, "objectToDeleteParameter");
+          batch.deleteObject(objectType.apiName, primaryKey);
+          break;
+        }
+        case "createLink": {
+          const aSideObjectTypeApiName = operation.aSideObjectTypeApiName;
+          const bSideObjectTypeApiName = operation.bSideObjectTypeApiName;
+          const linkTypeApiNameAtoB = operation.linkTypeApiNameAtoB;
+          const aSidePrimaryKey = params.aSidePrimaryKey || params.primaryKey_;
+          const bSidePrimaryKey = params.bSidePrimaryKey || params.linkedObjectPrimaryKey;
+          if (aSidePrimaryKey && bSidePrimaryKey) {
+            batch.addLink(aSideObjectTypeApiName, aSidePrimaryKey, linkTypeApiNameAtoB, bSideObjectTypeApiName, bSidePrimaryKey);
+          }
+          break;
+        }
+        case "deleteLink": {
+          const aSideObjectTypeApiName = operation.aSideObjectTypeApiName;
+          const bSideObjectTypeApiName = operation.bSideObjectTypeApiName;
+          const linkTypeApiNameAtoB = operation.linkTypeApiNameAtoB;
+          const aSidePrimaryKey = params.aSidePrimaryKey || params.primaryKey_;
+          const bSidePrimaryKey = params.bSidePrimaryKey || params.linkedObjectPrimaryKey;
+          if (aSidePrimaryKey && bSidePrimaryKey) {
+            batch.removeLink(aSideObjectTypeApiName, aSidePrimaryKey, linkTypeApiNameAtoB, bSideObjectTypeApiName, bSidePrimaryKey);
+          }
+          break;
+        }
+        // Handle other operation types as needed
+        case "createInterfaceObject":
+        case "modifyInterfaceObject":
+        case "deleteInterfaceObject":
+          throw new Error(`Operation type ${operation.type} not implemented yet`);
+        default:
+          throw new Error(`Unknown operation type: ${operation.type}`);
+      }
+    }
+  };
+}
+function extractAndDelete(obj, key) {
+  const value = obj[key];
+  delete obj[key];
+  return value;
+}
+function getObjectTypeForOperation(operation, fullMetadata) {
+  const objectTypeApiName = operation.objectTypeApiName;
+  const objectType = fullMetadata.objectTypes[objectTypeApiName];
+  !objectType ? process.env.NODE_ENV !== "production" ? invariant__default.default(false) : invariant__default.default(false) : void 0;
+  return objectType;
+}
+function paramsToDataValues(params, actionType) {
+  const objectData = {};
+  for (const [key, value] of Object.entries(params)) {
+    objectData[key] = toDataValue(value, actionType.parameters[key]);
+  }
+  return objectData;
+}
+function camelcase(apiName) {
+  return apiName.toLowerCase().replace(/[-_]+(.)?/g, (_, chr) => chr ? chr.toUpperCase() : "");
+}
+function toDataValue(value, param) {
+  if (param.dataType.type === "geohash" && typeof value === "string") {
+    return latLonStringToGeoJSON(value);
+  }
+  return value;
+}
+function latLonStringToGeoJSON(latLonStr) {
+  const [lat, lon] = latLonStr.split(",").map(Number);
+  if (isNaN(lat) || isNaN(lon) || lat < -90 || lat > 90 || lon < -180 || lon > 180) {
+    throw new Error("Invalid latitude or longitude");
+  }
   return {
-    name: "oac-vite-plugin",
+    type: "Point",
+    coordinates: [lon, lat]
+    // GeoJSON uses [longitude, latitude]
+  };
+}
+function handleObjectLinks(batch, fullMetadata, objectTypeApiName, primaryKey, params) {
+  fullMetadata.objectTypes[objectTypeApiName].linkTypes.forEach((link) => {
+    const cardinality = link.cardinality;
+    if (cardinality === "ONE") {
+      for (const foreignObject of batch.getObjects(link.objectTypeApiName)) {
+        if (anyValueMatches(params, foreignObject.__primaryKey)) {
+          batch.addLink(objectTypeApiName, primaryKey, link.apiName, link.objectTypeApiName, foreignObject.__primaryKey);
+        }
+      }
+    } else {
+      for (const foreignObject of batch.getObjects(link.objectTypeApiName)) {
+        if (anyValueMatches(foreignObject, primaryKey)) {
+          batch.addLink(objectTypeApiName, primaryKey, link.apiName, link.objectTypeApiName, foreignObject.__primaryKey);
+        }
+      }
+    }
+  });
+}
+function anyValueMatches(obj, primaryKey) {
+  return Object.values(obj).some((val) => val === primaryKey);
+}
+function readJsonFile(arg0) {
+  const content = fs__namespace.readFileSync(arg0, "utf-8");
+  return JSON.parse(content);
+}
+
+// src/applyOntologyAndSeed.ts
+async function applyOntologyAndSeed(fauxFoundry, ctx) {
+  const ontology = fauxFoundry.getDefaultOntology();
+  const ontologyFullMetadata = readJsonFile(ontologyFullMetadataPath(ctx.workDir));
+  registerOntologyFullMetadata(ontology, ontologyFullMetadata);
+  try {
+    if (ctx.hooks?.preSeed) {
+      ctx.logger.debug("calling preSeed hook");
+    }
+    await ctx.hooks?.preSeed?.(ontology);
+  } catch (e) {
+    ctx.logger.error(`Unhandled error from preSeed hook. Ignoring and continuing. ${util.inspect(e)}`);
+  }
+  ctx.logger.debug("applying seed data");
+  await applySeed(fauxFoundry, path__namespace.resolve(ctx.ontologyDir, "seed.ts"));
+}
+var OacServerContext = class extends OacContext {
+  constructor(config, server) {
+    super(config, server.config);
+    this.watcher = server.watcher;
+    this.emitter = new Emittery__default.default();
+  }
+};
+async function routeConnectToMsw(baseUrl, handlers, emitter, req, res, next) {
+  const method = req.method ?? "GET";
+  const canRequestHaveBody = method !== "HEAD" && method !== "GET";
+  const mockRequest = new Request(new URL(req.url, baseUrl), {
+    method,
+    headers: new Headers(req.headers),
+    credentials: "omit",
+    // @ts-expect-error Internal Undici property.
+    duplex: canRequestHaveBody ? "half" : void 0,
+    body: canRequestHaveBody ? stream.Readable.toWeb(req) : void 0
+  });
+  await faux.msw.handleRequest(mockRequest, crypto.randomUUID(), handlers, {
+    onUnhandledRequest: "bypass"
+  }, emitter, {
+    resolutionContext: {
+      baseUrl
+    },
     // eslint-disable-next-line @typescript-eslint/require-await
-    async configResolved(resolvedConfig) {
-      config = resolvedConfig;
+    async onMockedResponse(mockedResponse) {
+      const {
+        status,
+        statusText,
+        headers
+      } = mockedResponse;
+      res.statusCode = status;
+      res.statusMessage = statusText;
+      headers.forEach((value, name) => {
+        res.appendHeader(name, value);
+      });
+      if (mockedResponse.body) {
+        const stream$1 = stream.Readable.fromWeb(mockedResponse.body);
+        stream$1.pipe(res);
+      } else {
+        res.end();
+      }
     },
-    configureServer(server) {
-      const oacEmitter = watchOntologyAsCode({
-        watcher: server.watcher,
-        logger: server.config.logger,
-        ontologyDir
+    onPassthroughResponse() {
+      next();
+    }
+  });
+}
+
+// src/OacDevServer.ts
+var OacDevServer = class extends OacServerContext {
+  constructor(config, server) {
+    super(config, server);
+    this.foundry = this.fauxFoundryFactory();
+    this.emitter.on("generatedOntologyAssets", async () => {
+      this.foundry = this.fauxFoundryFactory();
+      await applyOntologyAndSeed(this.foundry, this);
+      server.hot.send({
+        type: "full-reload"
+      });
+    });
+    server.middlewares.use(this.#connectMiddleware);
+  }
+  #connectMiddleware = async (req, res, next) => {
+    const mswEmitter = new EventEmitter__default.default();
+    return void await routeConnectToMsw(this.serverUrl, this.foundry.handlers, mswEmitter, req, res, next);
+  };
+  watchOntologyAsCode = async () => {
+    const {
+      ontologyDir,
+      watcher
+    } = this;
+    this.logger.info(`Starting OAC file watcher for ${ontologyDir}`);
+    if (!fs__namespace.existsSync(ontologyDir)) {
+      fs__namespace.mkdirSync(ontologyDir, {
+        recursive: true
+      });
+    }
+    watcher.add(ontologyDir);
+    watcher.on("add", this.#handleOacFileChanged).on("change", this.#handleOacFileChanged).on("unlink", this.#handleOacFileChanged);
+    await this.#handleOacFileChanged(void 0);
+    return;
+  };
+  #handleOacFileChanged = async (filePath) => {
+    if (filePath && !filePath.startsWith(`${this.ontologyDir}/`)) {
+      return;
+    }
+    if (filePath) {
+      this.logger.info(`File ${filePath} changed.`);
+    }
+    try {
+      await fs__namespace.promises.mkdir(this.workDir, {
+        recursive: true
       });
-      const middlewareUrl = `http${server.config.server.https ? "s" : ""}://localhost:${server.config.server.port}`;
-      const foundryMiddlewareController = new FoundryMiddlewareController(middlewareUrl, `ri.ontology.main.ontology.00000000-0000-0000-0000-000000000000`, oacEmitter, opts?.hooks);
-      server.middlewares.use(foundryMiddlewareController.middleware);
+      await generateOntologyAssets(this);
+      await this.emitter.emit("generatedOntologyAssets");
+    } catch (error) {
+      this.logger.error(`Error generating ontology assets: ${util__namespace.inspect(error)}`);
+    }
+  };
+};
+
+// src/ontologyAsCode.ts
+function ontologyAsCode(oacConfig) {
+  let viteConfig;
+  return {
+    name: "oac-vite-plugin",
+    configResolved(resolvedConfig) {
+      viteConfig = resolvedConfig;
+    },
+    async configureServer(server) {
+      const oacDevServer = new OacDevServer(oacConfig, server);
+      await oacDevServer.watchOntologyAsCode();
     },
     async buildStart() {
-      if (config.command === "build") {
-        config.logger.info("Generating ontology assets for build...", {
-          timestamp: true
-        });
+      const ctx = new OacContext(oacConfig, viteConfig);
+      if (viteConfig.command === "build") {
+        ctx.logger.info("Generating ontology assets for build...");
         try {
-          await generateOntologyAssets({
-            logger: config.logger,
-            ontologyDir
-          });
-          config.logger.info("Successfully generated ontology assets for build", {
-            timestamp: true
+          await fs__namespace.promises.mkdir(ctx.workDir, {
+            recursive: true
           });
+          await generateOntologyAssets(ctx);
+          ctx.logger.info("Successfully generated ontology assets for build");
         } catch (error) {
-          config.logger.error(`Failed to generate ontology assets: ${error instanceof Error ? error.message : String(error)}`, {
-            timestamp: true
-          });
+          ctx.logger.error(`Failed to generate ontology assets: ${error instanceof Error ? error.message : String(error)}`);
           throw error;
         }
       }
@@ -624,6 +696,7 @@ function ontologyAsCode(opts) {
   };
 }
 
+exports.OacConfig = OacConfig;
 exports.ontologyAsCode = ontologyAsCode;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map