- generate cjs too

Author: sudarshan12s

libs/js/oracledb/langchain-oracledb/.gitignore

@@ -0,0 +1,3 @@
+index.cjs
+index.js
+index.d.ts

libs/js/oracledb/langchain-oracledb/babel.config.cjs

@@ -0,0 +1,4 @@
+// babel.config.js
+module.exports = {
+  presets: [["@babel/preset-env", { targets: { node: true } }]],
+};

libs/js/oracledb/langchain-oracledb/package.json

@@ -14,75 +14,64 @@
   },
   "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-oracle/",
   "scripts": {
-    "build": "tsc",
-    "build:compile": "tsc -p tsconfig.json",
-    "lint:eslint": "eslint --cache src/",
-    "lint:dpdm": "dpdm --skip-dynamic-imports circular --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
-    "lint": "pnpm lint:eslint && pnpm lint:dpdm",
-    "lint:fix": "pnpm lint:eslint --fix && pnpm lint:dpdm",
-    "pack:dry": "pnpm build && npm pack --dry-run",
-    "pack": "pnpm build && npm pack",
-    "publish": "pnpm build && npm publish",
-    "clean": "rm -rf dist/",
+    "build": "pnpm clean && pnpm build:esm && pnpm build:cjs && pnpm build:scripts",
+    "build:esm": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist/ && rm -rf dist/tests dist/**/tests",
+    "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rm -rf dist-cjs",
+    "build:watch": "node scripts/create-entrypoints.js && tsc --outDir dist/ --watch",
+    "build:scripts": "node scripts/create-entrypoints.js && node scripts/check-tree-shaking.js",
+    "lint": "NODE_OPTIONS=--max-old-space-size=4096 eslint src && dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
+    "lint:fix": "pnpm lint --fix",
+    "clean": "rm -rf dist/ && NODE_OPTIONS=--max-old-space-size=4096 node scripts/create-entrypoints.js pre",
+    "prepack": "pnpm build",
+    "release": "release-it --only-version --config .release-it.json",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:int": "vitest run --mode int",
     "test:standard:unit": "vitest run --mode standard-unit",
     "test:standard:int": "vitest run --mode standard-int",
     "test:standard": "pnpm test:standard:unit && pnpm test:standard:int",
-    "format": "prettier --config .prettierrc --write \"src\"",
-    "format:check": "prettier --config .prettierrc --check \"src\""
+    "format": "prettier --write \"src\"",
+    "format:check": "prettier --check \"src\""
   },
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
     "htmlparser2": "^10.0.0",
-    "oracledb": "^6.6.0",
+    "oracledb": "^6.10.0",
     "uuid": "^10.0.0"
   },
   "peerDependencies": {
     "@langchain/core": "^1.0.0",
     "@langchain/textsplitters": "^1.0.0"
   },
   "devDependencies": {
-    "@cfworker/json-schema": "^4.1.1",
-    "@eslint/js": "^9.39.1",
-    "@jest/globals": "^29.5.0",
     "@langchain/core": "^1.0.0",
     "@langchain/textsplitters": "^1.0.0",
-    "@swc/jest": "^0.2.29",
+    "@swc/core": "^1.3.90",
     "@tsconfig/recommended": "^1.0.3",
-    "@types/oracledb": "^6.6.0",
-    "@typescript-eslint/eslint-plugin": "^8.48.1",
-    "@typescript-eslint/parser": "^8.48.1",
-    "@vitest/coverage-v8": "^3.2.4",
-    "dotenv": "^16.6.1",
-    "dpdm": "^3.14.0",
-    "eslint": "^9",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-import": "^2.32.0",
+    "@types/oracledb": "^6.10.0",
+    "@typescript-eslint/eslint-plugin": "^6.12.0",
+    "@typescript-eslint/parser": "^6.12.0",
+    "@vitest/coverage-v8": "^4.0.15",
+    "dotenv": "^17.2.3",
+    "dpdm": "^3.12.0",
+    "eslint": "^8.33.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-no-instanceof": "^1.0.1",
-    "jest": "^29.5.0",
-    "jest-environment-node": "^29.6.4",
-    "jiti": "^2.6.1",
+    "eslint-plugin-prettier": "^4.2.1",
     "prettier": "^2.8.3",
     "rollup": "^4.5.2",
-    "ts-jest": "^29.1.0",
-    "typescript": "~5.8.3",
+    "typescript": "<5.2.0",
     "typescript-eslint": "^8.48.1",
-    "vitest": "^3.2.4",
-    "zod": "^3.25.76"
+    "vitest": "^3.2.4"
   },
   "publishConfig": {
     "access": "public"
   },
   "exports": {
     ".": {
-      "types": {
-        "import": "./index.d.ts",
-        "require": "./index.d.cts",
-        "default": "./index.d.ts"
-      },
+      "types": "./index.d.ts",
       "import": "./index.js",
       "require": "./index.cjs"
     },
@@ -92,7 +81,6 @@
     "dist/",
     "index.cjs",
     "index.js",
-    "index.d.ts",
-    "index.d.cts"
+    "index.d.ts"
   ]
 }

libs/js/oracledb/langchain-oracledb/scripts/check-tree-shaking.js

@@ -0,0 +1,80 @@
+import fs from "fs/promises";
+import { rollup } from "rollup";
+
+const packageJson = JSON.parse(await fs.readFile("package.json", "utf-8"));
+
+export function listEntrypoints() {
+  const exports = packageJson.exports;
+  const entrypoints = [];
+
+  for (const [key, value] of Object.entries(exports)) {
+    if (key === "./package.json") {
+      continue;
+    }
+    if (typeof value === "string") {
+      entrypoints.push(value);
+    } else if (typeof value === "object" && value.import) {
+      entrypoints.push(value.import);
+    }
+  }
+
+  return entrypoints;
+}
+
+export function listExternals() {
+  return [
+    ...Object.keys(packageJson.dependencies),
+    ...Object.keys(packageJson.peerDependencies ?? {}),
+    /node\:/,
+    /@langchain\/core\//,
+  ];
+}
+
+export async function checkTreeShaking() {
+  const externals = listExternals();
+  const entrypoints = listEntrypoints();
+  const consoleLog = console.log;
+  const reportMap = new Map();
+
+  for (const entrypoint of entrypoints) {
+    let sideEffects = "";
+
+    console.log = function (...args) {
+      const line = args.length ? args.join(" ") : "";
+      if (line.trim().startsWith("First side effect in")) {
+        sideEffects += line + "\n";
+      }
+    };
+
+    await rollup({
+      external: externals,
+      input: entrypoint,
+      experimentalLogSideEffects: true,
+    });
+
+    reportMap.set(entrypoint, {
+      log: sideEffects,
+      hasSideEffects: sideEffects.length > 0,
+    });
+  }
+
+  console.log = consoleLog;
+
+  let failed = false;
+  for (const [entrypoint, report] of reportMap) {
+    if (report.hasSideEffects) {
+      failed = true;
+      console.log("---------------------------------");
+      console.log(`Tree shaking failed for ${entrypoint}`);
+      console.log(report.log);
+    }
+  }
+
+  if (failed) {
+    process.exit(1);
+  } else {
+    console.log("Tree shaking checks passed!");
+  }
+}
+
+checkTreeShaking();

libs/js/oracledb/langchain-oracledb/scripts/create-entrypoints.js

@@ -0,0 +1,94 @@
+import * as fs from "fs";
+import * as path from "path";
+
+// This lists all the entrypoints for the library. Each key corresponds to an
+// importable path, eg. `import { AgentExecutor } from "langchain/agents"`.
+// The value is the path to the file in `src/` that exports the entrypoint.
+// This is used to generate the `exports` field in package.json.
+// Order is not important.
+const entrypoints = {
+  "index": "index"
+};
+
+// Entrypoints in this list require an optional dependency to be installed.
+// Therefore they are not tested in the generated test-exports-* packages.
+const requiresOptionalDependency = [];
+
+const updateJsonFile = (relativePath, updateFunction) => {
+  const contents = fs.readFileSync(relativePath).toString();
+  const res = updateFunction(JSON.parse(contents));
+  fs.writeFileSync(relativePath, JSON.stringify(res, null, 2) + "\n");
+};
+
+const generateFiles = () => {
+  const files = [...Object.entries(entrypoints), ["index", "index"]].flatMap(
+    ([key, value]) => {
+      const nrOfDots = key.split("/").length - 1;
+      const relativePath = "../".repeat(nrOfDots) || "./";
+      const compiledPath = `${relativePath}dist/${value}.js`;
+      return [
+        [
+          `${key}.cjs`,
+          `module.exports = require('${relativePath}dist/${value}.cjs');`,
+        ],
+        [`${key}.js`, `export * from '${compiledPath}'`],
+        [`${key}.d.ts`, `export * from '${compiledPath}'`],
+      ];
+    }
+  );
+
+  return Object.fromEntries(files);
+};
+
+const updateConfig = () => {
+  const generatedFiles = generateFiles();
+  const filenames = Object.keys(generatedFiles);
+
+  // Update package.json `exports` and `files` fields
+  updateJsonFile("./package.json", (json) => ({
+    ...json,
+    exports: Object.assign(
+      Object.fromEntries(
+        [...Object.keys(entrypoints)].map((key) => {
+          let entryPoint = {
+            types: `./${key}.d.ts`,
+            import: `./${key}.js`,
+            require: `./${key}.cjs`,
+          };
+
+          return [key === "index" ? "." : `./${key}`, entryPoint];
+        })
+      ),
+      { "./package.json": "./package.json" }
+    ),
+    files: ["dist/", ...filenames],
+  }));
+
+  // Write generated files
+  Object.entries(generatedFiles).forEach(([filename, content]) => {
+    fs.mkdirSync(path.dirname(filename), { recursive: true });
+    fs.writeFileSync(filename, content);
+  });
+
+  // Update .gitignore
+  fs.writeFileSync("./.gitignore", filenames.join("\n") + "\n");
+};
+
+const cleanGenerated = () => {
+  const filenames = Object.keys(generateFiles());
+  filenames.forEach((fname) => {
+    try {
+      fs.unlinkSync(fname);
+    } catch {
+      // ignore error
+    }
+  });
+};
+
+const command = process.argv[2];
+
+if (command === "pre") {
+  cleanGenerated();
+} else {
+  updateConfig();
+}

libs/js/oracledb/langchain-oracledb/scripts/identify-secrets.js

@@ -0,0 +1,77 @@
+import ts from "typescript";
+import * as fs from "fs";
+
+export function identifySecrets() {
+  const secrets = new Set();
+
+  const tsConfig = ts.parseJsonConfigFileContent(
+    ts.readJsonConfigFile("./tsconfig.json", (p) =>
+      fs.readFileSync(p, "utf-8")
+    ),
+    ts.sys,
+    "./src/"
+  );
+
+  for (const fileName of tsConfig.fileNames.filter(
+    (fn) => !fn.endsWith("test.ts")
+  )) {
+    const sourceFile = ts.createSourceFile(
+      fileName,
+      fs.readFileSync(fileName, "utf-8"),
+      tsConfig.options.target,
+      true
+    );
+    sourceFile.forEachChild((node) => {
+      switch (node.kind) {
+        case ts.SyntaxKind.ClassDeclaration:
+        case ts.SyntaxKind.ClassExpression: {
+          node.forEachChild((node) => {
+            // look for get lc_secrets()
+            switch (node.kind) {
+              case ts.SyntaxKind.GetAccessor: {
+                const property = node;
+                if (property.name.getText() === "lc_secrets") {
+                  // look for return { ... }
+                  property.body.statements.forEach((stmt) => {
+                    if (
+                      stmt.kind === ts.SyntaxKind.ReturnStatement &&
+                      stmt.expression.kind ===
+                        ts.SyntaxKind.ObjectLiteralExpression
+                    ) {
+                      // collect secret identifier
+                      stmt.expression.properties.forEach((element) => {
+                        if (
+                          element.initializer.kind ===
+                          ts.SyntaxKind.StringLiteral
+                        ) {
+                          const secret = element.initializer.text;
+
+                          if (secret.toUpperCase() !== secret) {
+                            throw new Error(
+                              `Secret identifier must be uppercase: ${secret} at ${fileName}`
+                            );
+                          }
+                          if (/\s/.test(secret)) {
+                            throw new Error(
+                              `Secret identifier must not contain whitespace: ${secret} at ${fileName}`
+                            );
+                          }
+
+                          secrets.add(secret);
+                        }
+                      });
+                    }
+                  });
+                }
+                break;
+              }
+            }
+          });
+          break;
+        }
+      }
+    });
+  }
+
+  return secrets;
+}