@semacode/cli 1.5.2 → 1.5.4

package/README.md

@@ -58,7 +58,9 @@ sema drift ./contratos-importados --json
 
 ## Persistencia vendor-first
 
-A CLI 1.5.2 entende blocos `database` e recursos de persistencia no IR, no formatador, no semantico, na importacao, no drift, no impact map, na renomeacao semantica assistida e no `verificar`. O objetivo nao e esconder diferencas entre bancos, e sim capturar essas diferencas no contrato.
+A CLI 1.5.4 entende blocos `database` e recursos de persistencia no IR, no formatador, no semantico, na importacao, no drift, no impact map, na renomeacao semantica assistida e no `verificar`. O objetivo nao e esconder diferencas entre bancos, e sim capturar essas diferencas no contrato.
+
+Nesta linha, o `drift` tambem passa a resolver melhor metodos JS/TS browser-side definidos via `Object.assign(...prototype...)` e a entrada padrao da CLI para de tropeçar em `exemplos/` quando o projeto real ja tem `contratos/`, `sema/` ou arquivos `.sema` na raiz.
 
 Cobertura publica:
 

package/dist/drift.js

@@ -202,6 +202,7 @@ function resolverRaizesExplicitasConfiguradas(contexto) {
 }
 function resolverRaizesIgnoradasPermitidas(contexto, segmentosIgnorados) {
     return [...new Set([
+            path.resolve(contexto.baseProjeto),
             resolverRaizEscopoReal(contexto),
             ...resolverRaizesExplicitasConfiguradas(contexto),
         ])]
@@ -1054,6 +1055,81 @@ function registrarSimboloTypeScript(simbolos, basesSimbolicas, arquivo, nome, no
         });
     }
 }
+function desembrulharExpressaoTypeScript(expr) {
+    let atual = expr;
+    while (true) {
+        if (ts.isParenthesizedExpression(atual) || ts.isAsExpression(atual) || ts.isSatisfiesExpression(atual) || ts.isTypeAssertionExpression(atual)) {
+            atual = atual.expression;
+            continue;
+        }
+        if (ts.isAwaitExpression(atual)) {
+            atual = atual.expression;
+            continue;
+        }
+        return atual;
+    }
+}
+function extrairNomePropriedadeTypeScript(nome, sourceFile) {
+    if (ts.isIdentifier(nome) || ts.isStringLiteralLike(nome) || ts.isNumericLiteral(nome)) {
+        return nome.text;
+    }
+    if (ts.isComputedPropertyName(nome) && ts.isStringLiteralLike(nome.expression)) {
+        return nome.expression.text;
+    }
+    const texto = nome.getText(sourceFile).trim();
+    return texto.length > 0 ? texto : undefined;
+}
+function extrairNomeClassePrototypeTypeScript(expr, sourceFile) {
+    const alvo = desembrulharExpressaoTypeScript(expr);
+    if (ts.isPropertyAccessExpression(alvo) && alvo.name.text === "prototype") {
+        return alvo.expression.getText(sourceFile).trim() || undefined;
+    }
+    return undefined;
+}
+function registrarMetodoTypeScriptProtoOuObjeto(simbolos, basesSimbolicas, arquivo, nomeMetodo, nomeClasse) {
+    if (!nomeMetodo) {
+        return;
+    }
+    if (nomeClasse) {
+        registrarSimboloTypeScript(simbolos, basesSimbolicas, arquivo, nomeMetodo, nomeClasse);
+    }
+    registrarSimboloTypeScript(simbolos, basesSimbolicas, arquivo, nomeMetodo);
+}
+function registrarMetodosObjectAssignTypeScript(simbolos, basesSimbolicas, arquivo, objeto, sourceFile, nomeClasse) {
+    for (const propriedade of objeto.properties) {
+        if (ts.isMethodDeclaration(propriedade) && propriedade.name) {
+            const nomeMetodo = extrairNomePropriedadeTypeScript(propriedade.name, sourceFile);
+            if (nomeMetodo) {
+                registrarMetodoTypeScriptProtoOuObjeto(simbolos, basesSimbolicas, arquivo, nomeMetodo, nomeClasse);
+            }
+            continue;
+        }
+        if (!ts.isPropertyAssignment(propriedade)) {
+            continue;
+        }
+        const nomeMetodo = extrairNomePropriedadeTypeScript(propriedade.name, sourceFile);
+        const valor = desembrulharExpressaoTypeScript(propriedade.initializer);
+        if (nomeMetodo && (ts.isFunctionExpression(valor) || ts.isArrowFunction(valor))) {
+            registrarMetodoTypeScriptProtoOuObjeto(simbolos, basesSimbolicas, arquivo, nomeMetodo, nomeClasse);
+        }
+    }
+}
+function registrarAtribuicaoPrototypeTypeScript(simbolos, basesSimbolicas, arquivo, sourceFile, esquerda, direita) {
+    const alvo = desembrulharExpressaoTypeScript(esquerda);
+    const valor = desembrulharExpressaoTypeScript(direita);
+    if (!ts.isPropertyAccessExpression(alvo) || !ts.isPropertyAccessExpression(alvo.expression)) {
+        return;
+    }
+    if (alvo.expression.name.text !== "prototype") {
+        return;
+    }
+    if (!ts.isFunctionExpression(valor) && !ts.isArrowFunction(valor)) {
+        return;
+    }
+    const nomeClasse = alvo.expression.expression.getText(sourceFile).trim();
+    const nomeMetodo = alvo.name.getText(sourceFile).trim();
+    registrarMetodoTypeScriptProtoOuObjeto(simbolos, basesSimbolicas, arquivo, nomeMetodo, nomeClasse || undefined);
+}
 function normalizarRelacaoConsumer(relacaoArquivo) {
     return relacaoArquivo.replace(/\\/g, "/");
 }
@@ -1541,6 +1617,27 @@ async function indexarTypeScript(diretorios) {
                     }
                 }
                 if (!ts.isClassDeclaration(node) || !node.name) {
+                    if (ts.isExpressionStatement(node)) {
+                        const expr = desembrulharExpressaoTypeScript(node.expression);
+                        if (ts.isCallExpression(expr)
+                            && ts.isPropertyAccessExpression(expr.expression)
+                            && ts.isIdentifier(expr.expression.expression)
+                            && expr.expression.expression.text === "Object"
+                            && expr.expression.name.text === "assign") {
+                            const nomeClasse = expr.arguments[0]
+                                ? extrairNomeClassePrototypeTypeScript(expr.arguments[0], sourceFile)
+                                : undefined;
+                            for (const argumento of expr.arguments.slice(1)) {
+                                const valor = desembrulharExpressaoTypeScript(argumento);
+                                if (ts.isObjectLiteralExpression(valor)) {
+                                    registrarMetodosObjectAssignTypeScript(simbolos, basesSimbolicas, arquivo, valor, sourceFile, nomeClasse);
+                                }
+                            }
+                        }
+                        else if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                            registrarAtribuicaoPrototypeTypeScript(simbolos, basesSimbolicas, arquivo, sourceFile, expr.left, expr.right);
+                        }
+                    }
                     continue;
                 }
                 const controllerDecorator = lerDecorator(node, ["Controller"]);