@bayoudhi/moose-lib-serverless 0.4.0 → 0.6.0

package/dist/moose-tspc.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// stub-native:@514labs/kafka-javascript
+var require_kafka_javascript = __commonJS({
+  "stub-native:@514labs/kafka-javascript"(exports2, module2) {
+    "use strict";
+    function createDeepProxy() {
+      var handler = {
+        get: function(_, prop) {
+          if (prop === "__esModule") return true;
+          if (prop === "default") return proxy;
+          if (typeof prop === "symbol") return void 0;
+          return proxy;
+        },
+        apply: function() {
+          return proxy;
+        },
+        construct: function() {
+          return proxy;
+        },
+        ownKeys: function() {
+          return ["length", "name", "prototype"];
+        },
+        getOwnPropertyDescriptor: function(target, prop) {
+          if (prop === "length" || prop === "name" || prop === "prototype") {
+            return Object.getOwnPropertyDescriptor(target, prop);
+          }
+          return void 0;
+        },
+        getPrototypeOf: function() {
+          return proxy;
+        }
+      };
+      var proxy = new Proxy(function() {
+      }, handler);
+      return proxy;
+    }
+    module2.exports = createDeepProxy();
+  }
+});
+
+// src/moose-tspc.ts
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_child_process = require("child_process");
+var import_fs3 = require("fs");
+var import_path3 = __toESM(require("path"));
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var MOOSE_COMPILER_PLUGINS = [
+  {
+    transform: "./node_modules/@bayoudhi/moose-lib-serverless/dist/compilerPlugin.js"
+    // No longer using transformProgram - direct typia integration eliminates
+    // the need for program replacement and the associated incremental compilation issues
+  },
+  {
+    // Keep typia plugin for users who use typia directly (not through Moose resources)
+    transform: "typia/lib/transform"
+  }
+];
+var MOOSE_COMPILER_OPTIONS = {
+  experimentalDecorators: true,
+  esModuleInterop: true,
+  // Disable strict module syntax checking to avoid dual-package type conflicts
+  // This prevents errors where the same type imported with different resolution
+  // modes (CJS vs ESM) is treated as incompatible
+  verbatimModuleSyntax: false
+};
+function getSourceDir() {
+  return process.env.MOOSE_SOURCE_DIR || "app";
+}
+function detectModuleSystem(projectRoot2 = process.cwd()) {
+  const pkgPath = import_path.default.join(projectRoot2, "package.json");
+  if ((0, import_fs.existsSync)(pkgPath)) {
+    try {
+      const pkgContent = (0, import_fs.readFileSync)(pkgPath, "utf-8");
+      const pkg = JSON.parse(pkgContent);
+      if (pkg.type === "module") {
+        return "esm";
+      }
+    } catch (e) {
+      console.debug(
+        `[moose] Failed to parse package.json at ${pkgPath}, defaulting to CJS:`,
+        e
+      );
+    }
+  }
+  return "cjs";
+}
+function getModuleOptions(moduleSystem) {
+  if (moduleSystem === "esm") {
+    return {
+      module: "ES2022",
+      moduleResolution: "bundler"
+    };
+  }
+  return {
+    module: "CommonJS",
+    moduleResolution: "Node"
+  };
+}
+var import_fs2 = require("fs");
+var import_path2 = __toESM(require("path"));
+var import_client = require("@clickhouse/client");
+var import_kafka_javascript = require_kafka_javascript();
+var { Kafka } = import_kafka_javascript.KafkaJS;
+function walkDirectory(dir, extensions) {
+  const results = [];
+  if (!(0, import_fs2.existsSync)(dir)) {
+    return results;
+  }
+  try {
+    const entries = (0, import_fs2.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = import_path2.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules") {
+          results.push(...walkDirectory(fullPath, extensions));
+        }
+      } else if (entry.isFile()) {
+        const ext = import_path2.default.extname(entry.name);
+        if (extensions.includes(ext)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch (e) {
+    console.debug(`[moose] Failed to read directory ${dir}:`, e);
+  }
+  return results;
+}
+function addJsExtensionToImports(content, fileDir) {
+  const fromPattern = /(from\s+['"])(\.\.?\/[^'"]*?)(['"])/g;
+  const bareImportPattern = /(import\s+['"])(\.\.?\/[^'"]*?)(['"])/g;
+  const dynamicPattern = /(import\s*\(\s*['"])(\.\.?\/[^'"]*?)(['"])/g;
+  let result = content;
+  result = result.replace(fromPattern, (match, prefix, importPath, quote) => {
+    return rewriteImportPath(match, prefix, importPath, quote, fileDir);
+  });
+  result = result.replace(
+    bareImportPattern,
+    (match, prefix, importPath, quote) => {
+      return rewriteImportPath(match, prefix, importPath, quote, fileDir);
+    }
+  );
+  result = result.replace(
+    dynamicPattern,
+    (match, prefix, importPath, quote) => {
+      return rewriteImportPath(match, prefix, importPath, quote, fileDir);
+    }
+  );
+  return result;
+}
+function rewriteImportPath(match, prefix, importPath, quote, fileDir) {
+  if (/\.[cm]?js$/.test(importPath)) {
+    return match;
+  }
+  if (/\.json$/.test(importPath)) {
+    return match;
+  }
+  if (fileDir) {
+    const resolvedPath = import_path2.default.resolve(fileDir, importPath);
+    if ((0, import_fs2.existsSync)(`${resolvedPath}.js`)) {
+      return `${prefix}${importPath}.js${quote}`;
+    }
+    if ((0, import_fs2.existsSync)(import_path2.default.join(resolvedPath, "index.js"))) {
+      return `${prefix}${importPath}/index.js${quote}`;
+    }
+    if ((0, import_fs2.existsSync)(`${resolvedPath}.mjs`)) {
+      return `${prefix}${importPath}.mjs${quote}`;
+    }
+    if ((0, import_fs2.existsSync)(import_path2.default.join(resolvedPath, "index.mjs"))) {
+      return `${prefix}${importPath}/index.mjs${quote}`;
+    }
+    if ((0, import_fs2.existsSync)(`${resolvedPath}.cjs`)) {
+      return `${prefix}${importPath}.cjs${quote}`;
+    }
+    if ((0, import_fs2.existsSync)(import_path2.default.join(resolvedPath, "index.cjs"))) {
+      return `${prefix}${importPath}/index.cjs${quote}`;
+    }
+  }
+  return `${prefix}${importPath}.js${quote}`;
+}
+function rewriteImportExtensions(outDir2) {
+  const files = walkDirectory(outDir2, [".js", ".mjs"]);
+  for (const filePath of files) {
+    const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
+    const fileDir = import_path2.default.dirname(filePath);
+    const rewritten = addJsExtensionToImports(content, fileDir);
+    if (content !== rewritten) {
+      (0, import_fs2.writeFileSync)(filePath, rewritten, "utf-8");
+    }
+  }
+}
+var outDir = process.argv[2] || ".moose/compiled";
+var projectRoot = process.cwd();
+var tsconfigPath = import_path3.default.join(projectRoot, "tsconfig.json");
+var tempTsconfigPath = import_path3.default.join(projectRoot, "tsconfig.moose-build.json");
+if (!(0, import_fs3.existsSync)(tsconfigPath)) {
+  console.error("Error: tsconfig.json not found in", projectRoot);
+  process.exit(1);
+}
+console.log(`Compiling TypeScript to ${outDir}...`);
+try {
+  const moduleSystem = detectModuleSystem(projectRoot);
+  const moduleOptions = getModuleOptions(moduleSystem);
+  console.log(
+    `Using ${moduleSystem.toUpperCase()} module output (detected from package.json)...`
+  );
+  const buildTsconfig = {
+    extends: "./tsconfig.json",
+    compilerOptions: {
+      ...MOOSE_COMPILER_OPTIONS,
+      ...moduleOptions,
+      plugins: [...MOOSE_COMPILER_PLUGINS],
+      // Skip type checking of declaration files to avoid dual-package conflicts
+      // This must be in compilerOptions (not just CLI flag) to fully work
+      skipLibCheck: true,
+      skipDefaultLibCheck: true,
+      // Additional settings to handle module resolution conflicts
+      allowSyntheticDefaultImports: true,
+      // IMPORTANT: Build Safety Trade-off
+      // noEmitOnError: false allows JavaScript emission even with type errors.
+      // This is intentional for Docker builds to succeed even when TypeScript
+      // finds type issues. The trade-off is that type errors that could cause
+      // runtime failures will not block the build - they will be logged as
+      // warnings below. For strict type safety, users should run `npx tsc --noEmit`
+      // before building to catch type errors that could indicate runtime issues.
+      noEmitOnError: false
+    }
+  };
+  (0, import_fs3.writeFileSync)(tempTsconfigPath, JSON.stringify(buildTsconfig, null, 2));
+  console.log("Created temporary tsconfig with moose plugins...");
+  try {
+    (0, import_child_process.execFileSync)(
+      "npx",
+      [
+        "tspc",
+        "-p",
+        tempTsconfigPath,
+        "--outDir",
+        outDir,
+        "--rootDir",
+        ".",
+        "--sourceMap",
+        "--inlineSources"
+      ],
+      {
+        stdio: "inherit",
+        cwd: projectRoot
+      }
+    );
+    console.log("TypeScript compilation complete.");
+  } catch (compileError) {
+    const sourceDir = getSourceDir();
+    const outputIndexPath = import_path3.default.join(
+      projectRoot,
+      outDir,
+      sourceDir,
+      "index.js"
+    );
+    if ((0, import_fs3.existsSync)(outputIndexPath)) {
+      console.warn("");
+      console.warn("\u26A0\uFE0F  BUILD SAFETY WARNING \u26A0\uFE0F");
+      console.warn(
+        "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"
+      );
+      console.warn(
+        "TypeScript detected type errors but JavaScript was still emitted."
+      );
+      console.warn("");
+      console.warn(
+        "IMPORTANT: Type errors can indicate code that will fail at runtime."
+      );
+      console.warn(
+        "While this build will succeed, the resulting code may crash when:"
+      );
+      console.warn("  - Functions receive unexpected argument types");
+      console.warn(
+        "  - Properties are accessed on potentially null/undefined values"
+      );
+      console.warn("  - Incorrect types flow through your application logic");
+      console.warn("");
+      console.warn(
+        "RECOMMENDATION: Run `npx tsc --noEmit` to review type errors before"
+      );
+      console.warn(
+        "deploying to production. Fix any errors that could cause runtime issues."
+      );
+      console.warn(
+        "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"
+      );
+      console.warn("");
+      console.log("TypeScript compilation complete (with type warnings).");
+    } else {
+      console.error("Compilation failed - no output files generated.");
+      throw compileError;
+    }
+  }
+  if (moduleSystem === "esm") {
+    console.log("Post-processing ESM imports to add .js extensions...");
+    const fullOutDir = import_path3.default.join(projectRoot, outDir);
+    rewriteImportExtensions(fullOutDir);
+    console.log("ESM import rewriting complete.");
+  }
+  console.log("Compilation complete.");
+} catch (error) {
+  console.error("Build process failed:", error);
+  process.exit(1);
+} finally {
+  if ((0, import_fs3.existsSync)(tempTsconfigPath)) {
+    (0, import_fs3.unlinkSync)(tempTsconfigPath);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bayoudhi/moose-lib-serverless",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Serverless-compatible subset of @514labs/moose-lib for AWS Lambda and edge runtimes. Provides OlapTable, Stream, Workflow, View, and other Moose SDK classes without native C++ dependencies (Kafka, Temporal). Includes a patched compiler plugin for type-driven schema injection.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -21,6 +21,9 @@
     },
     "./dist/compilerPlugin.js": "./dist/compilerPlugin.js"
   },
+  "bin": {
+    "moose-tspc": "./dist/moose-tspc.js"
+  },
   "files": [
     "dist",
     "LICENSE",
@@ -44,6 +47,7 @@
     "compiler-plugin"
   ],
   "dependencies": {
+    "@514labs/moose-cli": "0.6.416",
     "@clickhouse/client": "1.8.1",
     "csv-parse": "^5.5.5",
     "jose": "5.9.2",