@fairfox/polly 0.19.0 → 0.20.0

package/dist/tools/verify/src/cli.js

@@ -1362,13 +1362,25 @@ var init_tla = __esm(() => {
       if (assignment.value !== null)
         return true;
       const fieldConfig = state[assignment.field];
-      return !!(fieldConfig && typeof fieldConfig === "object" && ("values" in fieldConfig) && fieldConfig.values);
+      if (!fieldConfig || typeof fieldConfig !== "object")
+        return false;
+      if ("abstract" in fieldConfig && fieldConfig.abstract)
+        return true;
+      if ("nullable" in fieldConfig && fieldConfig.nullable)
+        return true;
+      return !!(("values" in fieldConfig) && fieldConfig.values);
     }
     mapNullAssignment(assignment, state) {
       if (assignment.value !== null)
         return assignment;
       const fieldConfig = state[assignment.field];
-      if (fieldConfig && typeof fieldConfig === "object" && "values" in fieldConfig && fieldConfig.values) {
+      if (!fieldConfig || typeof fieldConfig !== "object")
+        return assignment;
+      if ("abstract" in fieldConfig && fieldConfig.abstract)
+        return assignment;
+      if ("nullable" in fieldConfig && fieldConfig.nullable)
+        return assignment;
+      if ("values" in fieldConfig && fieldConfig.values) {
         const nullValue = fieldConfig.values[fieldConfig.values.length - 1];
         return { ...assignment, value: nullValue };
       }
@@ -2069,6 +2081,9 @@ var init_tla = __esm(() => {
     }
     tryAbstractType(fieldConfig) {
       if ("abstract" in fieldConfig && fieldConfig.abstract === true) {
+        if ("nullable" in fieldConfig && fieldConfig.nullable === true) {
+          return "Value \\union {NULL}";
+        }
         return "Value";
       }
       return null;
@@ -2236,6 +2251,9 @@ var init_tla = __esm(() => {
     }
     getInitialValue(fieldConfig) {
       if ("abstract" in fieldConfig && fieldConfig.abstract === true) {
+        if ("nullable" in fieldConfig && fieldConfig.nullable === true) {
+          return "NULL";
+        }
         return '"v1"';
       }
       if (Array.isArray(fieldConfig)) {
@@ -2927,7 +2945,7 @@ class ConfigGenerator {
     this.addHeader();
     this.addImports();
     this.addExport();
-    this.addStateConfig(analysis.fields);
+    this.addStateConfig(analysis.fields, analysis.resources);
     this.addMessagesConfig();
     this.addBehaviorConfig();
     this.closeExport();
@@ -2993,7 +3011,7 @@ class ConfigGenerator {
     this.indent--;
     this.line("})");
   }
-  addStateConfig(fields) {
+  addStateConfig(fields, resources) {
     this.line("state: {");
     this.indent++;
     for (let i = 0;i < fields.length; i++) {
@@ -3005,6 +3023,18 @@ class ConfigGenerator {
       }
       this.addFieldConfig(field);
     }
+    if (resources && resources.length > 0) {
+      if (fields.length > 0) {
+        this.line("");
+      }
+      this.line("// ─── $resource async lifecycle fields (auto-generated) ───");
+      for (const resource of resources) {
+        this.line("");
+        this.line(`// ${resource.name}: fetch lifecycle status`);
+        this.line(`"${resource.name}_status": { type: "enum", values: ["idle", "loading", "success", "error"] },`);
+        this.line(`"${resource.name}_error": { type: "boolean" },`);
+      }
+    }
     this.indent--;
     this.line("},");
     this.line("");
@@ -4335,12 +4365,13 @@ class HandlerExtractor {
     const stateConstraints = [];
     const globalStateConstraints = [];
     const verifiedStates = [];
+    const resources = [];
     this.warnings = [];
     const allSourceFiles = this.project.getSourceFiles();
     const entryPoints = allSourceFiles.filter((f) => this.isWithinPackage(f.getFilePath()));
     this.debugLogSourceFiles(allSourceFiles, entryPoints);
     for (const entryPoint of entryPoints) {
-      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
+      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources);
     }
     if (verifiedStates.length > 0) {
       if (process.env["POLLY_DEBUG"]) {
@@ -4372,10 +4403,11 @@ class HandlerExtractor {
       stateConstraints,
       globalStateConstraints,
       verifiedStates,
+      resources,
       warnings: this.warnings
     };
   }
-  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates) {
+  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources) {
     const filePath = sourceFile.getFilePath();
     if (this.analyzedFiles.has(filePath)) {
       return;
@@ -4393,6 +4425,20 @@ class HandlerExtractor {
     globalStateConstraints.push(...fileGlobalConstraints);
     const fileVerifiedStates = this.extractVerifiedStatesFromFile(sourceFile);
     verifiedStates.push(...fileVerifiedStates);
+    const fileResources = this.extractResourcesFromFile(sourceFile, filePath);
+    for (const resource of fileResources) {
+      resources.push(resource);
+      const context = this.inferContext(filePath);
+      const syntheticHandlers = this.createResourceHandlers(resource, context);
+      for (const handler of syntheticHandlers) {
+        handlers.push(handler);
+        if (this.isValidTLAIdentifier(handler.messageType)) {
+          messageTypes.add(handler.messageType);
+        } else {
+          invalidMessageTypes.add(handler.messageType);
+        }
+      }
+    }
     const importDeclarations = sourceFile.getImportDeclarations();
     for (const importDecl of importDeclarations) {
       const importedFile = importDecl.getModuleSpecifierSourceFile();
@@ -4404,7 +4450,7 @@ class HandlerExtractor {
           }
           continue;
         }
-        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
+        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources);
       } else if (process.env["POLLY_DEBUG"]) {
         const specifier = importDecl.getModuleSpecifierValue();
         if (!specifier.startsWith("node:") && !this.isNodeModuleImport(specifier)) {
@@ -6294,6 +6340,125 @@ class HandlerExtractor {
     }
     return name || funcName;
   }
+  extractResourcesFromFile(sourceFile, filePath) {
+    const resources = [];
+    sourceFile.forEachDescendant((node) => {
+      if (!Node2.isCallExpression(node))
+        return;
+      const resource = this.extractResourcePattern(node, filePath);
+      if (resource) {
+        resources.push(resource);
+      }
+    });
+    return resources;
+  }
+  extractResourcePattern(node, filePath) {
+    const expression = node.getExpression();
+    if (!Node2.isIdentifier(expression))
+      return null;
+    if (expression.getText() !== "$resource")
+      return null;
+    const args = node.getArguments();
+    if (args.length < 2)
+      return null;
+    const nameArg = args[0];
+    if (!nameArg || !Node2.isStringLiteral(nameArg))
+      return null;
+    const name = nameArg.getLiteralValue();
+    const optionsArg = args[1];
+    if (!optionsArg || !Node2.isObjectLiteralExpression(optionsArg))
+      return null;
+    const sourceSignals = this.extractResourceSourceReads(optionsArg);
+    const variableName = this.getVariableNameFromParent(node) || name;
+    if (process.env["POLLY_DEBUG"]) {
+      console.log(`[DEBUG] Found $resource: ${variableName} (name: "${name}") with source signals: [${sourceSignals.join(", ")}]`);
+    }
+    return {
+      name,
+      variableName,
+      filePath,
+      line: node.getStartLineNumber(),
+      sourceSignals
+    };
+  }
+  extractResourceSourceReads(optionsObj) {
+    const signals = [];
+    const sourceProp = optionsObj.getProperty("source");
+    if (!sourceProp || !Node2.isPropertyAssignment(sourceProp))
+      return signals;
+    const sourceInit = sourceProp.getInitializer();
+    if (!sourceInit)
+      return signals;
+    sourceInit.forEachDescendant((node) => {
+      if (!Node2.isPropertyAccessExpression(node))
+        return;
+      const text = node.getText();
+      const match = text.match(/^(\w+)\.value(?:\.(\w+))?$/);
+      if (match) {
+        const signalName = match[1];
+        const fieldName = match[2];
+        if (fieldName) {
+          signals.push(`${signalName}_${fieldName}`);
+        } else {
+          signals.push(signalName);
+        }
+      }
+    });
+    return signals;
+  }
+  createResourceHandlers(resource, context) {
+    const { name, filePath, line } = resource;
+    const location = { file: filePath, line };
+    const fetchStart = {
+      messageType: `${name}_FetchStart`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "loading" },
+        { field: `${name}_error`, value: false }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status !== "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    const fetchSuccess = {
+      messageType: `${name}_FetchSuccess`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "success" },
+        { field: `${name}_error`, value: false }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status === "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    const fetchError = {
+      messageType: `${name}_FetchError`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "error" },
+        { field: `${name}_error`, value: true }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status === "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    return [fetchStart, fetchSuccess, fetchError];
+  }
 }
 
 // tools/analysis/src/extract/types.ts
@@ -6327,7 +6492,9 @@ class TypeExtractor {
       fields,
       handlers: completeHandlers,
       stateConstraints: handlerAnalysis.stateConstraints,
-      globalStateConstraints: handlerAnalysis.globalStateConstraints
+      globalStateConstraints: handlerAnalysis.globalStateConstraints,
+      verifiedStates: handlerAnalysis.verifiedStates,
+      resources: handlerAnalysis.resources
     };
   }
   extractHandlerAnalysis() {
@@ -7422,4 +7589,4 @@ main().catch((error) => {
   process.exit(1);
 });
 
-//# debugId=E5DA6950FD1E0C7764756E2164756E21
+//# debugId=AA5557533E02826364756E2164756E21