deepline 0.1.155 → 0.1.157

package/dist/plays/bundle-play-file.mjs

@@ -19,7 +19,9 @@ import {
   resolve
 } from "path";
 import { builtinModules } from "module";
-import { build } from "esbuild";
+import { Parser } from "acorn";
+import { tsPlugin } from "acorn-typescript";
+import { build, transformSync } from "esbuild";
 
 // ../shared_libs/play-runtime/backend.ts
 var PLAY_RUNTIME_BACKENDS = {
@@ -364,24 +366,6 @@ function findSourceImportReferences(sourceCode) {
     (left, right) => left.line === right.line ? left.column - right.column : left.line - right.line
   );
 }
-function unquoteStringLiteral(literal) {
-  const trimmed = literal.trim();
-  const quote = trimmed[0];
-  if (quote !== '"' && quote !== "'" && quote !== "`" || trimmed[trimmed.length - 1] !== quote) {
-    return null;
-  }
-  if (quote === "`") {
-    const value = trimmed.slice(1, -1);
-    return value.includes("${") ? null : value;
-  }
-  try {
-    return JSON.parse(
-      quote === '"' ? trimmed : `"${trimmed.slice(1, -1).replace(/"/g, '\\"')}"`
-    );
-  } catch {
-    return trimmed.slice(1, -1);
-  }
-}
 function findMatchingBrace(source, openIndex) {
   const structuralSource = maskSourceForStructure(source);
   let depth = 0;
@@ -395,198 +379,351 @@ function findMatchingBrace(source, openIndex) {
   }
   return -1;
 }
-function findMatchingParen(source, openIndex) {
-  const structuralSource = maskSourceForStructure(source);
-  let depth = 0;
-  for (let index = openIndex; index < structuralSource.length; index += 1) {
-    const char = structuralSource[index];
-    if (char === "(") depth += 1;
-    if (char === ")") {
-      depth -= 1;
-      if (depth === 0) return index;
-    }
-  }
-  return -1;
+function extractDefinedPlayName(sourceCode) {
+  return extractDefinedPlayMetadata(sourceCode, null)?.name ?? null;
 }
-function splitTopLevelArguments(source) {
-  const args = [];
-  const structuralSource = maskSourceForStructure(source);
-  let start = 0;
-  let parenDepth = 0;
-  let braceDepth = 0;
-  let bracketDepth = 0;
-  for (let index = 0; index < structuralSource.length; index += 1) {
-    const char = structuralSource[index];
-    if (char === "(") parenDepth += 1;
-    if (char === ")") parenDepth -= 1;
-    if (char === "{") braceDepth += 1;
-    if (char === "}") braceDepth -= 1;
-    if (char === "[") bracketDepth += 1;
-    if (char === "]") bracketDepth -= 1;
-    if (char === "," && parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
-      args.push(source.slice(start, index).trim());
-      start = index + 1;
+function extractDefinedPlayNameForExport(sourceCode, exportName) {
+  return extractDefinedPlayMetadata(sourceCode, exportName)?.name ?? null;
+}
+function extractDefinedPlayDescription(sourceCode) {
+  return extractDefinedPlayMetadata(sourceCode, null)?.description ?? null;
+}
+function extractDefinedPlayDescriptionForExport(sourceCode, exportName) {
+  return extractDefinedPlayMetadata(sourceCode, exportName)?.description ?? null;
+}
+var TypeScriptParser = Parser.extend(
+  tsPlugin({
+    allowSatisfies: true,
+    jsx: {
+      allowNamespaces: true,
+      allowNamespacedObjects: true
+    }
+  })
+);
+function parsePlaySourceAst(sourceCode) {
+  try {
+    return TypeScriptParser.parse(sourceCode, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      allowHashBang: true
+    });
+  } catch {
+    try {
+      const transformed = transformSync(sourceCode, {
+        loader: "ts",
+        format: "esm",
+        target: "esnext",
+        legalComments: "none",
+        sourcemap: false
+      }).code;
+      return Parser.parse(transformed, {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        allowHashBang: true
+      });
+    } catch {
+      return null;
     }
   }
-  const finalArg = source.slice(start).trim();
-  if (finalArg) args.push(finalArg);
-  return args;
 }
-function extractStringProperty(objectSource, propertyName) {
-  for (const entry of splitTopLevelArguments(objectSource)) {
-    const structuralEntry = stripCommentsToSpaces(entry).trim();
-    const match = structuralEntry.match(
-      new RegExp(
-        `^(?:${propertyName}|['"]${propertyName}['"])\\s*:\\s*((['"\`])(?:\\\\.|(?!\\2)[\\s\\S])*\\2)\\s*$`
-      )
-    );
-    const value = match?.[1] ? unquoteStringLiteral(match[1]) : null;
-    if (value?.trim()) return value.trim();
+function getIdentifierName(node) {
+  return isAstNode(node) && node.type === "Identifier" ? typeof node.name === "string" ? node.name : null : null;
+}
+function isAstNode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+function astArray(value) {
+  return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function memberExpressionPath(node) {
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+  if (expression.type === "Identifier" && typeof expression.name === "string") {
+    return [expression.name];
+  }
+  if (expression.type !== "MemberExpression") return null;
+  const objectPath = memberExpressionPath(
+    isAstNode(expression.object) ? expression.object : null
+  );
+  if (!objectPath) return null;
+  const property = isAstNode(expression.property) ? expression.property : null;
+  if (!property) return null;
+  if (!expression.computed && property.type === "Identifier") {
+    return typeof property.name === "string" ? [...objectPath, property.name] : null;
+  }
+  if (expression.computed && property.type === "Literal") {
+    return typeof property.value === "string" ? [...objectPath, property.value] : null;
   }
   return null;
 }
-function extractDefinedPlayName(sourceCode) {
-  for (const call of findDefinePlayCalls(sourceCode)) {
-    const name = nameFromDefinePlayArguments(sourceCode, call.arguments);
-    if (name) return name;
+function commonJsExportName(left) {
+  const path = memberExpressionPath(left);
+  if (!path) return null;
+  if (path.length === 2 && path[0] === "module" && path[1] === "exports") {
+    return "default";
+  }
+  if (path.length === 3 && path[0] === "module" && path[1] === "exports") {
+    return path[2] || null;
+  }
+  if (path.length === 2 && path[0] === "exports") {
+    return path[1] || null;
   }
   return null;
 }
-function extractDefinedPlayNameForExport(sourceCode, exportName) {
-  return findDefinedPlayMetadata(
-    sourceCode,
-    exportName,
-    nameFromDefinePlayArguments
+function isDefinePlayCallExpression(node) {
+  if (!node || node.type !== "CallExpression") return false;
+  const callee = isAstNode(node.callee) ? node.callee : null;
+  if (!callee) return false;
+  if (callee.type === "Identifier") {
+    return callee.name === "definePlay" || callee.name === "defineWorkflow";
+  }
+  if (callee.type === "MemberExpression" && isAstNode(callee.property)) {
+    const property = callee.property;
+    return !callee.computed && property.type === "Identifier" && (property.name === "definePlay" || property.name === "defineWorkflow");
+  }
+  return false;
+}
+function canResolveDeclarationInitializer(declarationKind, initializer) {
+  return declarationKind === "const" || isDefinePlayCallExpression(initializer);
+}
+function buildPlayMetadataContext(ast) {
+  const declarations = /* @__PURE__ */ new Map();
+  const namedExports = /* @__PURE__ */ new Map();
+  const commonJsExports = /* @__PURE__ */ new Map();
+  let defaultExport = null;
+  for (const statement of astArray(ast.body)) {
+    if (statement.type === "VariableDeclaration") {
+      for (const declaration of astArray(statement.declarations)) {
+        const name = getIdentifierName(declaration.id);
+        if (!name) continue;
+        const initializer = isAstNode(declaration.init) ? declaration.init : null;
+        declarations.set(
+          name,
+          canResolveDeclarationInitializer(statement.kind, initializer) ? initializer : null
+        );
+      }
+      continue;
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      defaultExport = isAstNode(statement.declaration) ? statement.declaration : null;
+      continue;
+    }
+    if (statement.type === "TSExportAssignment") {
+      defaultExport = isAstNode(statement.expression) ? statement.expression : null;
+      continue;
+    }
+    if (statement.type === "ExportNamedDeclaration") {
+      if (isAstNode(statement.declaration) && statement.declaration.type === "VariableDeclaration") {
+        for (const declaration of astArray(statement.declaration.declarations)) {
+          const name = getIdentifierName(declaration.id);
+          if (!name) continue;
+          const initializer = isAstNode(declaration.init) ? declaration.init : null;
+          declarations.set(
+            name,
+            canResolveDeclarationInitializer(
+              statement.declaration.kind,
+              initializer
+            ) ? initializer : null
+          );
+          namedExports.set(name, name);
+        }
+      }
+      for (const specifier of astArray(statement.specifiers)) {
+        const localName = getIdentifierName(specifier.local);
+        const exportedName = getIdentifierName(specifier.exported) ?? (isAstNode(specifier.exported) && specifier.exported.type === "Literal" && typeof specifier.exported.value === "string" ? specifier.exported.value : null);
+        if (localName && exportedName) {
+          namedExports.set(exportedName, localName);
+        }
+      }
+    }
+    if (statement.type === "ExpressionStatement" && isAstNode(statement.expression) && statement.expression.type === "AssignmentExpression") {
+      const exportName = commonJsExportName(
+        isAstNode(statement.expression.left) ? statement.expression.left : null
+      );
+      if (exportName && isAstNode(statement.expression.right)) {
+        commonJsExports.set(exportName, statement.expression.right);
+      }
+    }
+  }
+  return { declarations, namedExports, commonJsExports, defaultExport };
+}
+function unwrapStaticExpression(node) {
+  let current = node ?? null;
+  while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression")) {
+    current = isAstNode(current.expression) ? current.expression : null;
+  }
+  return current;
+}
+function staticStringFromExpression(node, context, seen = /* @__PURE__ */ new Set()) {
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+  if (expression.type === "Literal") {
+    const value = expression.value;
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+  }
+  if (expression.type === "TemplateLiteral" && astArray(expression.expressions).length === 0) {
+    const firstQuasi = astArray(expression.quasis)[0];
+    const cooked = firstQuasi && typeof firstQuasi.value === "object" ? firstQuasi.value.cooked : null;
+    return typeof cooked === "string" && cooked.trim() ? cooked.trim() : null;
+  }
+  const identifier = getIdentifierName(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return staticStringFromExpression(
+    context.declarations.get(identifier),
+    context,
+    seen
   );
 }
-function extractDefinedPlayDescription(sourceCode) {
-  return findDefinedPlayMetadata(
-    sourceCode,
-    null,
-    descriptionFromDefinePlayArguments
-  );
+function propertyNameFromKey(property) {
+  if (property.computed) return null;
+  const key = isAstNode(property.key) ? property.key : null;
+  if (!key) return null;
+  if (key.type === "Identifier" && typeof key.name === "string") {
+    return key.name;
+  }
+  if (key.type === "Literal" && typeof key.value === "string") {
+    return key.value;
+  }
+  return null;
 }
-function extractDefinedPlayDescriptionForExport(sourceCode, exportName) {
-  return findDefinedPlayMetadata(
-    sourceCode,
-    exportName,
-    descriptionFromDefinePlayArguments
+function objectExpressionFromNode(node, context, seen = /* @__PURE__ */ new Set()) {
+  const expression = unwrapStaticExpression(node);
+  if (!expression) return null;
+  if (expression.type === "ObjectExpression") return expression;
+  const identifier = getIdentifierName(expression);
+  if (!identifier || seen.has(identifier)) return null;
+  seen.add(identifier);
+  return objectExpressionFromNode(
+    context.declarations.get(identifier),
+    context,
+    seen
   );
 }
-function findDefinedPlayMetadata(sourceCode, exportName, getMetadata) {
-  const resolvedExportName = exportName === "default" ? findDefaultExportIdentifier(sourceCode) ?? exportName : exportName;
-  for (const call of findDefinePlayCalls(sourceCode)) {
-    if (resolvedExportName && call.exportName !== resolvedExportName) {
+function stringPropertyFromObjectExpression(node, propertyName, context, seenObjects = /* @__PURE__ */ new Set()) {
+  const object = objectExpressionFromNode(node, context);
+  if (!object || seenObjects.has(object)) return null;
+  seenObjects.add(object);
+  let value = null;
+  for (const property of astArray(object.properties)) {
+    if (property.type === "SpreadElement") {
+      const spreadValue = stringPropertyFromObjectExpression(
+        isAstNode(property.argument) ? property.argument : null,
+        propertyName,
+        context,
+        seenObjects
+      );
+      if (spreadValue) value = spreadValue;
       continue;
     }
-    const value = getMetadata(sourceCode, call.arguments);
-    if (value) return value;
+    if (property.type !== "Property") continue;
+    if (propertyNameFromKey(property) !== propertyName) continue;
+    const propertyValue = property.shorthand ? property.key : property.value;
+    value = staticStringFromExpression(
+      isAstNode(propertyValue) ? propertyValue : null,
+      context
+    );
   }
-  return null;
+  return value;
 }
-function findDefinePlayCalls(sourceCode) {
-  const source = maskSourceForStructure(sourceCode);
-  const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
-  const calls = [];
-  for (const match of source.matchAll(callPattern)) {
-    const callStart = match.index;
-    const openParen = callStart + match[0].length - 1;
-    const closeParen = findMatchingParen(sourceCode, openParen);
-    if (closeParen < 0) continue;
-    calls.push({
-      arguments: splitTopLevelArguments(
-        sourceCode.slice(openParen + 1, closeParen)
-      ),
-      exportName: exportNameForDefinePlayCall(sourceCode, callStart)
-    });
+function isDefinePlayCallee(node) {
+  const callee = unwrapStaticExpression(node);
+  if (!callee) return false;
+  if (callee.type === "Identifier" && (callee.name === "definePlay" || callee.name === "defineWorkflow")) {
+    return true;
+  }
+  if (callee.type === "MemberExpression" && isAstNode(callee.property)) {
+    const property = callee.property;
+    return !callee.computed && property.type === "Identifier" && (property.name === "definePlay" || property.name === "defineWorkflow");
   }
-  return calls;
+  return false;
 }
-function findDefaultExportIdentifier(sourceCode) {
-  const source = maskSourceForStructure(sourceCode);
-  const pattern = /\bexport\s+default\s+([A-Za-z_$][\w$]*)/g;
-  for (const match of source.matchAll(pattern)) {
-    const afterIdentifier = match.index + match[0].length;
-    const nextNonSpace = source.slice(afterIdentifier).match(/\S/)?.[0] ?? "";
-    if (nextNonSpace !== "(") return match[1] ?? null;
+function playMetadataFromDefinePlayCall(node, context) {
+  const expression = unwrapStaticExpression(node);
+  if (!expression || expression.type !== "CallExpression" || !isDefinePlayCallee(isAstNode(expression.callee) ? expression.callee : null)) {
+    return null;
   }
-  return null;
+  const args = astArray(expression.arguments);
+  const firstArg = args[0] ?? null;
+  const objectName = stringPropertyFromObjectExpression(firstArg, "id", context);
+  const name = objectName ?? staticStringFromExpression(firstArg, context);
+  let description = stringPropertyFromObjectExpression(firstArg, "description", context) ?? null;
+  for (let index = args.length - 1; !description && index >= 2; index -= 1) {
+    description = stringPropertyFromObjectExpression(
+      args[index],
+      "description",
+      context
+    );
+  }
+  if (!name && !description) return null;
+  return { name, description };
 }
-function nameFromDefinePlayArguments(sourceCode, args) {
-  const firstArg = args[0]?.trim();
-  if (!firstArg) return null;
-  if (/^(['"`])/.test(firstArg))
-    return unquoteStringLiteral(firstArg)?.trim() ?? null;
-  const objectSource = objectLiteralBodyFromArgument(sourceCode, firstArg);
-  if (objectSource) {
-    return extractStringProperty(objectSource, "id");
+function resolveExportExpression(exportName, context) {
+  if (exportName === "default") {
+    const commonJsDefault = context.commonJsExports.get("default");
+    if (commonJsDefault) {
+      const commonJsDefaultIdentifier = getIdentifierName(
+        unwrapStaticExpression(commonJsDefault)
+      );
+      return commonJsDefaultIdentifier ? context.declarations.get(commonJsDefaultIdentifier) ?? commonJsDefault : commonJsDefault;
+    }
+    const defaultExpression = unwrapStaticExpression(context.defaultExport);
+    const defaultIdentifier = getIdentifierName(defaultExpression);
+    if (!defaultIdentifier) {
+      const defaultExportName = context.namedExports.get("default");
+      return defaultExportName ? context.declarations.get(defaultExportName) ?? null : defaultExpression;
+    }
+    return defaultIdentifier ? context.declarations.get(defaultIdentifier) ?? context.defaultExport : context.defaultExport;
+  }
+  if (exportName) {
+    const commonJsExport = context.commonJsExports.get(exportName);
+    if (commonJsExport) {
+      const commonJsExportIdentifier = getIdentifierName(
+        unwrapStaticExpression(commonJsExport)
+      );
+      return commonJsExportIdentifier ? context.declarations.get(commonJsExportIdentifier) ?? commonJsExport : commonJsExport;
+    }
+    const localName = context.namedExports.get(exportName) ?? exportName;
+    return context.declarations.get(localName) ?? null;
   }
   return null;
 }
-function descriptionFromDefinePlayArguments(sourceCode, args) {
-  const firstArgDescription = descriptionFromDefinePlayArgument(
-    sourceCode,
-    args[0]
+function extractDefinedPlayMetadata(sourceCode, exportName) {
+  const ast = parsePlaySourceAst(sourceCode);
+  if (!ast) return null;
+  const context = buildPlayMetadataContext(ast);
+  const exportedExpression = resolveExportExpression(exportName, context);
+  const exportedMetadata = playMetadataFromDefinePlayCall(
+    exportedExpression,
+    context
   );
-  if (firstArgDescription) return firstArgDescription;
-  for (let index = args.length - 1; index >= 2; index -= 1) {
-    const description = descriptionFromDefinePlayArgument(
-      sourceCode,
-      args[index]
+  if (exportedMetadata) return exportedMetadata;
+  if (exportName) return null;
+  if (context.defaultExport) {
+    const directDefaultMetadata = playMetadataFromDefinePlayCall(
+      context.defaultExport,
+      context
     );
-    if (description) return description;
+    if (directDefaultMetadata) return directDefaultMetadata;
+    const defaultIdentifier = getIdentifierName(context.defaultExport);
+    if (defaultIdentifier) {
+      const defaultMetadata = playMetadataFromDefinePlayCall(
+        context.declarations.get(defaultIdentifier),
+        context
+      );
+      if (defaultMetadata) return defaultMetadata;
+    }
   }
-  return null;
-}
-function descriptionFromDefinePlayArgument(sourceCode, arg) {
-  const trimmed = arg?.trim();
-  if (!trimmed) return null;
-  const objectSource = objectLiteralBodyFromArgument(sourceCode, trimmed);
-  if (!objectSource) return null;
-  return extractStringProperty(objectSource, "description");
-}
-function objectLiteralBodyFromArgument(sourceCode, arg) {
-  const trimmed = arg.trim();
-  if (trimmed.startsWith("{")) {
-    const closeBrace = findMatchingBrace(trimmed, 0);
-    return closeBrace >= 0 ? trimmed.slice(1, closeBrace) : trimmed.slice(1);
-  }
-  if (!/^[A-Za-z_$][\w$]*$/.test(trimmed)) return null;
-  return findTopLevelObjectLiteralBody(sourceCode, trimmed);
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function findTopLevelObjectLiteralBody(sourceCode, identifier) {
-  const source = maskSourceForStructure(sourceCode);
-  const pattern = new RegExp(
-    `(?:^|[;\\n])\\s*(?:export\\s+)?(?:const|let|var)\\s+${escapeRegExp(
-      identifier
-    )}(?:\\s*:[^=;]+)?\\s*=\\s*{`,
-    "g"
-  );
-  for (const match of source.matchAll(pattern)) {
-    const openBrace = source.indexOf("{", match.index);
-    if (openBrace < 0) continue;
-    const closeBrace = findMatchingBrace(sourceCode, openBrace);
-    if (closeBrace < 0) continue;
-    return sourceCode.slice(openBrace + 1, closeBrace);
+  for (const expression of context.declarations.values()) {
+    const metadata = playMetadataFromDefinePlayCall(expression, context);
+    if (metadata) return metadata;
+  }
+  for (const expression of context.commonJsExports.values()) {
+    const metadata = playMetadataFromDefinePlayCall(expression, context);
+    if (metadata) return metadata;
   }
   return null;
 }
-function exportNameForDefinePlayCall(sourceCode, callStart) {
-  const source = maskSourceForStructure(sourceCode);
-  const structuralPrefix = source.slice(Math.max(0, callStart - 500), callStart).trimEnd();
-  if (/\bexport\s+default\s*$/.test(structuralPrefix)) return "default";
-  const variableMatch = structuralPrefix.match(
-    /\bexport\s+(?:declare\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:[^=;]+)?\s*=\s*$/
-  );
-  if (variableMatch?.[1]) return variableMatch[1];
-  const localVariableMatch = structuralPrefix.match(
-    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)(?:\s*:[^=;]+)?\s*=\s*$/
-  );
-  return localVariableMatch?.[1] ?? null;
-}
 function canonicalizeRootPlayNameForWorkersRuntimeHash(sourceCode) {
   const source = stripCommentsToSpaces(sourceCode);
   const callPattern = /(?:\b[A-Za-z_$][\w$]*\s*\.\s*)?\b(?:definePlay|defineWorkflow)\s*\(/g;
@@ -1682,7 +1819,7 @@ function stripCommentsToSpaces2(source) {
     (match, prefix) => prefix + " ".repeat(Math.max(0, match.length - prefix.length))
   );
 }
-function unquoteStringLiteral2(literal) {
+function unquoteStringLiteral(literal) {
   const trimmed = literal.trim();
   const quote = trimmed[0];
   if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
@@ -1742,7 +1879,7 @@ function isRuntimeInputExpression(expression) {
 function resolveStringExpression(expression, constants) {
   const value = stripOuterParens(expression);
   if (/^(['"])(?:\\.|(?!\1)[\s\S])*\1$/.test(value)) {
-    return unquoteStringLiteral2(value);
+    return unquoteStringLiteral(value);
   }
   if (/^`(?:\\.|[^`$]|\$(?!\{))*`$/.test(value)) {
     return value.slice(1, -1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.155",
+  "version": "0.1.157",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {
@@ -46,6 +46,8 @@
     "prepublishOnly": "bun ../scripts/sync-sdk-package-version.ts && tsup"
   },
   "dependencies": {
+    "acorn": "^8.17.0",
+    "acorn-typescript": "^1.4.13",
     "commander": "^14.0.3",
     "csv-parse": "^5.6.0",
     "csv-stringify": "^6.5.0",