@openfn/project 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -15,6 +15,8 @@ declare class Workflow {
     options: any;
     constructor(workflow: l.Workflow);
     get steps(): WithMeta<l.Job & l.Trigger>[];
+    get start(): string | undefined;
+    set start(s: string);
     _buildIndex(): void;
     set(id: string, props: Partial<l.Job | l.StepEdge>): this;
     get(id: string): WithMeta<l.Step | l.Trigger | l.StepEdge>;
@@ -43,6 +45,7 @@ type FromPathConfig = l.WorkspaceConfig & {
 
 type FromFsConfig = {
     root: string;
+    config?: Partial<l.WorkspaceConfig>;
     logger?: Logger;
 };
 
@@ -66,6 +69,7 @@ type MergeProjectOptions = {
 declare class Workspace {
     config: l.WorkspaceConfig;
     activeProject?: l.ProjectMeta;
+    root: string;
     private projects;
     private projectPaths;
     private isValid;
@@ -77,6 +81,8 @@ declare class Workspace {
     get(nameyThing: string): Project | null;
     getProjectPath(id: string): string | undefined;
     getActiveProject(): Project | undefined;
+    getCheckedOutProject(): Promise<Project>;
+    getCredentialMap(): string | undefined;
     getConfig(): Partial<l.WorkspaceConfig>;
     get activeProjectId(): unknown;
     get valid(): boolean;

package/dist/index.js

@@ -105,7 +105,16 @@ var Workflow = class {
     };
     this.workflow = clone(workflow);
     this.workflow.history = workflow.history?.length ? workflow.history : [];
-    const { id, name, openfn, steps, history, ...options } = workflow;
+    const {
+      id,
+      name,
+      openfn,
+      steps,
+      history,
+      start: _start,
+      options,
+      ...rest
+    } = workflow;
     if (!(id || name)) {
       throw new Error("A Workflow MUST have a name or id");
     }
@@ -116,12 +125,18 @@ var Workflow = class {
       this.workflow.name = this.name;
     }
     this.openfn = openfn;
-    this.options = options;
+    this.options = Object.assign({}, options, rest);
     this._buildIndex();
   }
   get steps() {
     return this.workflow.steps;
   }
+  get start() {
+    return this.workflow.start;
+  }
+  set start(s) {
+    this.workflow.start = s;
+  }
   _buildIndex() {
     for (const step of this.workflow.steps) {
       const s = step;
@@ -361,11 +376,17 @@ var mapWorkflow = (workflow) => {
       } else {
         e.source_job_id = node.id;
       }
-      if (rules.condition === true) {
-        e.condition_type = "always";
-      } else if (rules.condition === false) {
-        e.condition_type = "never";
-      } else if (typeof rules.condition === "string") {
+      if (rules.condition) {
+        if (typeof rules.condition === "boolean") {
+          e.condition_type = rules.condition ? "always" : "never";
+        } else if (rules.condition.match(
+          /^(always|never|on_job_success|on_job_failure)$/
+        )) {
+          e.condition_type = rules.condition;
+        } else {
+          e.condition_type = "js_expression";
+          e.condition_expression = rules.condition;
+        }
       }
       wfState.edges.push(e);
     });
@@ -383,6 +404,7 @@ import { readFileSync } from "node:fs";
 import path from "node:path";
 import { pickBy, isNil as isNil2 } from "lodash-es";
 var buildConfig = (config = {}) => ({
+  credentials: "credentials.yaml",
   ...config,
   dirs: {
     projects: config.dirs?.projects ?? ".projects",
@@ -499,6 +521,7 @@ var extractWorkflow = (project, workflowId) => {
   const wf = {
     id: workflow.id,
     name: workflow.name,
+    start: workflow.start,
     // Note: if no options are defined, options will serialize to an empty object
     // Not crazy about this - maybe we should do something better? Or do we like the consistency?
     options: workflow.options,
@@ -652,20 +675,23 @@ var from_app_state_default = (state, meta = {}, config = {}) => {
   proj.workflows = stateJson.workflows.map(mapWorkflow2);
   return new Project(proj, config);
 };
-var mapTriggerEdgeCondition = (edge) => {
+var mapEdge = (edge) => {
   const e = {
     disabled: !edge.enabled
   };
-  if (edge.condition_type === "always") {
-    e.condition = true;
-  } else if (edge.condition_type === "never") {
-    e.condition = false;
-  } else {
+  if (edge.condition_type === "js_expression") {
     e.condition = edge.condition_expression;
+  } else if (edge.condition_type) {
+    e.condition = edge.condition_type;
+  }
+  if (edge.condition_label) {
+    e.name = edge.condition_label;
+  }
+  if (edge.id) {
+    e.openfn = {
+      uuid: edge.id
+    };
   }
-  e.openfn = {
-    uuid: edge.id
-  };
   return e;
 };
 var mapWorkflow2 = (workflow) => {
@@ -681,6 +707,9 @@ var mapWorkflow2 = (workflow) => {
   }
   workflow.triggers.forEach((trigger) => {
     const { type, ...otherProps } = trigger;
+    if (!mapped.start) {
+      mapped.start = `trigger-${type}`;
+    }
     const connectedEdges = edges.filter(
       (e) => e.source_trigger_id === trigger.id
     );
@@ -693,7 +722,7 @@ var mapWorkflow2 = (workflow) => {
         if (!target) {
           throw new Error(`Failed to find ${edge.target_job_id}`);
         }
-        obj[slugify(target.name)] = mapTriggerEdgeCondition(edge);
+        obj[slugify(target.name)] = mapEdge(edge);
         return obj;
       }, {})
     });
@@ -723,7 +752,7 @@ var mapWorkflow2 = (workflow) => {
     if (outboundEdges.length) {
       s.next = outboundEdges.reduce((next, edge) => {
         const target = jobs.find((j) => j.id === edge.target_job_id);
-        next[slugify(target.name)] = mapTriggerEdgeCondition(edge);
+        next[slugify(target.name)] = mapEdge(edge);
         return next;
       }, {});
     }
@@ -739,16 +768,13 @@ import path2 from "node:path";
 // src/parse/from-project.ts
 var from_project_default = (data, config) => {
   let rawJson = ensure_json_default(data);
-  let json;
   if (rawJson.cli?.version ?? rawJson.version) {
-    json = from_v2(rawJson);
-  } else {
-    json = from_v1(rawJson);
+    return new Project_default(from_v2(rawJson), config);
   }
-  return new Project_default(json, config);
+  return from_v1(rawJson, config);
 };
-var from_v1 = (data) => {
-  return from_app_state_default(data);
+var from_v1 = (data, config = {}) => {
+  return from_app_state_default(data, {}, config);
 };
 var from_v2 = (data) => {
   return {
@@ -780,7 +806,7 @@ var parseProject = async (options) => {
   const { root, logger } = options;
   const { type, content } = findWorkspaceFile(root);
   const context = loadWorkspaceFile(content, type);
-  const config = buildConfig(context.workspace);
+  const config = buildConfig(options.config ?? context.workspace);
   const proj = {
     id: context.project?.id,
     name: context.project?.name,
@@ -790,14 +816,26 @@ var parseProject = async (options) => {
   };
   const workflowDir = config.workflowRoot ?? config.dirs?.workflows ?? "workflows";
   const fileType = config.formats?.workflow ?? "yaml";
-  const pattern = `${root}/${workflowDir}/*/*.${fileType}`;
+  const pattern = path3.resolve(root, workflowDir) + `/**/*.${fileType}`;
   const candidateWfs = await glob(pattern, {
     ignore: ["**node_modules/**", "**tmp**"]
   });
   for (const filePath of candidateWfs) {
     const candidate = await fs.readFile(filePath, "utf-8");
     try {
-      const wf = fileType === "yaml" ? yamlToJson(candidate) : JSON.parse(candidate);
+      let wf = fileType === "yaml" ? yamlToJson(candidate) : JSON.parse(candidate);
+      if (wf.workflow) {
+        if (wf.options) {
+          const { start, ...rest } = wf.options;
+          if (start) {
+            wf.workflow.start = start;
+          }
+          if (rest) {
+            wf.workflow.options = Object.assign({}, wf.workflow.options, rest);
+          }
+        }
+        wf = wf.workflow;
+      }
       if (wf.id && Array.isArray(wf.steps)) {
         for (const step of wf.steps) {
           if (step.expression && step.expression.endsWith(".js")) {
@@ -1445,6 +1483,7 @@ var Workspace = class {
   config;
   // TODO activeProject should be the actual project
   activeProject;
+  root;
   projects = [];
   projectPaths = /* @__PURE__ */ new Map();
   isValid = false;
@@ -1452,6 +1491,7 @@ var Workspace = class {
   // Set validate to false to suppress warnings if a Workspace doesn't exist
   // This is appropriate if, say, fetching a project for the first time
   constructor(workspacePath, logger, validate = true) {
+    this.root = workspacePath;
     this.logger = logger ?? createLogger("Workspace", { level: "info" });
     let context = { workspace: void 0, project: void 0 };
     try {
@@ -1517,6 +1557,12 @@ var Workspace = class {
   getActiveProject() {
     return this.projects.find((p) => p.openfn?.uuid === this.activeProject?.uuid) ?? this.projects.find((p) => p.id === this.activeProject?.id);
   }
+  getCheckedOutProject() {
+    return Project.from("fs", { root: this.root, config: this.config });
+  }
+  getCredentialMap() {
+    return this.config.credentials;
+  }
   // TODO this needs to return default values
   // We should always rely on the workspace to load these values
   getConfig() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/project",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Read, serialize, replicate and sync OpenFn projects",
   "type": "module",
   "exports": {