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

package/build/cjs/index.cjs

@@ -0,0 +1,629 @@
+'use strict';
+
+var path2 = require('path');
+var faux = require('@osdk/faux');
+var EventEmitter = require('events');
+var jiti = require('jiti');
+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 }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+
+// 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);
+  }
+  #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, {
+    recursive: true
+  });
+  const [sourceFiles, targetFiles] = await Promise.all([getAllFiles(sourceDir), getAllFiles(targetDir)]);
+  let updatedCount = 0;
+  let addedCount = 0;
+  let removedCount = 0;
+  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);
+    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), {
+          recursive: true
+        });
+        await fs2__namespace.default.promises.copyFile(sourceFile, targetFile);
+        addedCount++;
+        logger.info(`Added: ${relativeFile}`, {
+          timestamp: true
+        });
+      } else if (isDifferent) {
+        await fs2__namespace.default.promises.copyFile(sourceFile, targetFile);
+        updatedCount++;
+        logger.info(`Updated: ${targetFile}`, {
+          timestamp: true
+        });
+      } 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
+      });
+    }
+  }
+  for (const relativeFile of targetFiles) {
+    if (!sourceFiles.includes(relativeFile)) {
+      const targetFile = path2__default.default.join(targetDir, relativeFile);
+      try {
+        await fs2__namespace.default.promises.unlink(targetFile);
+        removedCount++;
+        logger.info(`Removed: ${relativeFile}`, {
+          timestamp: true
+        });
+      } catch (error) {
+        const errorMsg = `Failed to remove ${relativeFile}: ${error instanceof Error ? error.message : String(error)}`;
+        errors.push(errorMsg);
+        logger.error(errorMsg, {
+          timestamp: true
+        });
+      }
+    }
+  }
+  try {
+    await removeEmptyDirectories(targetDir);
+  } catch (error) {
+    logger.warn(`Failed to clean up empty directories: ${error instanceof Error ? error.message : String(error)}`, {
+      timestamp: true
+    });
+  }
+  if (errors.length > 0) {
+    logger.warn(`Encountered ${errors.length} errors during sync`, {
+      timestamp: true
+    });
+  }
+}
+async function removeEmptyDirectories(dir) {
+  try {
+    const entries = await fs2__namespace.default.promises.readdir(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subdir = path2__default.default.join(dir, entry.name);
+        await removeEmptyDirectories(subdir);
+      }
+    }
+    const remainingEntries = await fs2__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);
+      }
+    }
+  } catch (error) {
+  }
+}
+async function getFileHash(filePath) {
+  try {
+    const content = await fs2__namespace.default.promises.readFile(filePath);
+    return crypto2__default.default.createHash("sha256").update(content).digest("hex");
+  } catch (error) {
+    return "";
+  }
+}
+async function areFilesDifferent(sourceFile, targetFile) {
+  try {
+    const [sourceHash, targetHash] = await Promise.all([getFileHash(sourceFile), getFileHash(targetFile)]);
+    return sourceHash !== targetHash || sourceHash === "";
+  } catch (error) {
+    return true;
+  }
+}
+async function getAllFiles(dir, baseDir = dir) {
+  const files = [];
+  try {
+    const entries = await fs2__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);
+      if (entry.isDirectory()) {
+        const subFiles = await getAllFiles(fullPath, baseDir);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        files.push(relativePath);
+      }
+    }
+  } catch (error) {
+  }
+  return files;
+}
+
+// src/generateOntologyAssets.ts
+var NOISY = false;
+async function generateOntologyAssets({
+  logger,
+  ontologyDir
+}) {
+  if (!fs2__namespace.default.existsSync(ontologyDir)) {
+    fs2__namespace.default.mkdirSync(ontologyDir, {
+      recursive: true
+    });
+    logger.info("Created .ontology directory", {
+      timestamp: true
+    });
+  }
+  await ontologyJsToIr(logger);
+  await ontologyIrToFullMetadata(logger);
+  await fullMetadataToOsdk(logger);
+}
+async function ontologyJsToIr(logger) {
+  const {
+    stdout,
+    stderr,
+    exitCode
+  } = await execa.execa("pnpm", ["exec", "maker", "-i", ".ontology/ontology.mjs", "-o", ".ontology.ir.json"]);
+  if (exitCode !== 0) {
+    logger.error(`Ontology IR generation failed with exit code ${exitCode}`, {
+      timestamp: true
+    });
+    if (stderr) {
+      logger.error(`Command stderr: ${stderr}`, {
+        timestamp: true
+      });
+    }
+    throw new Error(`Failed to generate ontology IR: exit code ${exitCode}`);
+  }
+}
+async function ontologyIrToFullMetadata(logger) {
+  try {
+    const irContent = await fs2__namespace.default.promises.readFile("./.ontology.ir.json", {
+      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) ;
+  } catch (error) {
+    logger.error(`Failed to convert IR to full metadata: ${error instanceof Error ? error.message : String(error)}`, {
+      timestamp: true
+    });
+    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, {
+    recursive: true,
+    force: true
+  });
+  await fs2__namespace.default.promises.mkdir(tempDir, {
+    recursive: true
+  });
+  try {
+    const tempSrcDir = path2__default.default.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) ;
+    if (stderr) {
+      logger.error(`OSDK generation stderr: ${stderr}`, {
+        timestamp: true
+      });
+    }
+    if (exitCode === 0) {
+      const targetDir = ".osdk/src";
+      try {
+        if (NOISY) ;
+        await syncDirectories(tempSrcDir, targetDir, logger);
+        if (NOISY) ;
+        await fs2__namespace.default.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
+        });
+        throw error;
+      }
+    } else {
+      logger.error(`OSDK generation failed with exit code ${exitCode}`, {
+        timestamp: true
+      });
+      logger.error(`Temporary files left at: ${tempDir}`, {
+        timestamp: true
+      });
+      throw new Error(`OSDK generation failed with exit code ${exitCode}`);
+    }
+  } catch (error) {
+    try {
+      await fs2__namespace.default.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
+      });
+    }
+    throw error;
+  }
+}
+function watchOntologyAsCode({
+  watcher,
+  logger,
+  ontologyDir
+}) {
+  const emitter = new EventEmitter__default.default();
+  logger.info(`Starting OAC file watcher for ${ontologyDir}`, {
+    timestamp: true
+  });
+  if (!fs2__namespace.default.existsSync(ontologyDir)) {
+    fs2__namespace.default.mkdirSync(ontologyDir, {
+      recursive: true
+    });
+    logger.info("Created .ontology directory", {
+      timestamp: true
+    });
+  }
+  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;
+    }
+    if (filePath) {
+      logger.info(`File ${filePath} changed.`, {
+        timestamp: true
+      });
+    }
+    (async () => {
+      await generateOntologyAssets({
+        logger,
+        ontologyDir
+      });
+      emitter.emit("generated");
+    })().catch((error) => {
+      console.error(error);
+      logger.error(`Error executing command: ${error.message}`, {
+        timestamp: true
+      });
+    });
+  }
+}
+
+// src/index.ts
+function ontologyAsCode(opts) {
+  const ontologyDir = path2__default.default.resolve(".ontology");
+  let config;
+  return {
+    name: "oac-vite-plugin",
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    configureServer(server) {
+      const oacEmitter = watchOntologyAsCode({
+        watcher: server.watcher,
+        logger: server.config.logger,
+        ontologyDir
+      });
+      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);
+    },
+    async buildStart() {
+      if (config.command === "build") {
+        config.logger.info("Generating ontology assets for build...", {
+          timestamp: true
+        });
+        try {
+          await generateOntologyAssets({
+            logger: config.logger,
+            ontologyDir
+          });
+          config.logger.info("Successfully generated ontology assets for build", {
+            timestamp: true
+          });
+        } catch (error) {
+          config.logger.error(`Failed to generate ontology assets: ${error instanceof Error ? error.message : String(error)}`, {
+            timestamp: true
+          });
+          throw error;
+        }
+      }
+    }
+  };
+}
+
+exports.ontologyAsCode = ontologyAsCode;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map