@fnet/cli 0.100.2 → 0.101.0

package/dist/fnet/index.B5vpZn1Z.js

@@ -0,0 +1,53 @@
+import fnetConfig from '@fnet/config';
+import fnetDeployer from '@flownet/lib-to-docker';
+import cloneDeep from 'lodash.clonedeep';
+import semver from 'semver';
+
+async function deployToDocker({
+  atom,
+  target,
+  onProgress,
+  projectDir,
+  dependencies,
+  context,
+  yamlTarget
+}) {
+
+  const deployerName = 'docker';
+
+  if (onProgress) await onProgress({ message: `Deploying it as ${deployerName} package.` });
+
+  const config = target?.config ? await fnetConfig({
+    name: target.config,
+    dir: projectDir,
+    optional: true,
+    transferEnv: false,
+    tags: context.tags
+  }) : undefined;
+
+  const nextVersion = semver.inc(target.version || "0.1.0", "patch");
+  target.params.version = nextVersion; // TODO: remove this line
+  target.version = nextVersion;
+  yamlTarget.set('version', nextVersion);
+
+
+  const params = cloneDeep(target.params);
+
+  params.dependencies = cloneDeep(dependencies);
+
+  const args = {
+    atom,
+    params,
+    config: config?.config,
+    src: projectDir,
+    dest: projectDir,
+  };
+
+  const result = await fnetDeployer(args);
+
+  return {
+    deployer: result,
+  };
+}
+
+export { deployToDocker as default };

package/dist/fnet/index.B6WHm9H0.js

@@ -0,0 +1,106 @@
+import semver from 'semver';
+import fnetConfig from '@fnet/config';
+import fs from 'fs';
+import fnetShellJs from '@fnet/shelljs';
+import FormData from 'form-data';
+
+async function deployToFnetNode({ setProgress, context, deploymentProject, deploymentProjectTarget: target, yamlTarget }) {
+
+  await setProgress({ message: "Deploying it as fnet node." });
+
+  const { file: configFile, data: config } = await fnetConfig({
+    name: target.config || "fnet-node",
+    dir: context.project.projectDir,
+    tags: context.tags
+  });
+
+  if (!config.env.ATOM_API_URL) throw new Error(`ATOM_API_URL is required in ${configFile}`);
+  if (!config.env.ATOM_API_USERNAME) throw new Error(`ATOM_API_USERNAME is required in ${configFile}`);
+  if (!config.env.ATOM_API_PASSWORD) throw new Error(`ATOM_API_PASSWORD is required in ${configFile}`);
+
+  const apiTokenUrl = `${config.env.ATOM_API_URL}/v1/auth/token`;
+  const username = config.env.ATOM_API_USERNAME;
+  const password = config.env.ATOM_API_PASSWORD;
+
+  const tokenResponse = await fetch(apiTokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ username, password })
+  });
+
+  if (!tokenResponse.ok) {
+    throw new Error(`Failed to fetch token: ${tokenResponse.statusText}`);
+  }
+
+  const tokenData = await tokenResponse.json();
+  const access_token = tokenData?.access_token;
+
+  if (!access_token) throw new Error(`Invalid access_token from ${apiTokenUrl}`);
+
+  deploymentProject.isDirty = true;
+  const newVersion = semver.inc(target.version, "patch");
+  target.params.version = newVersion; // TODO: remove this line
+  target.version = newVersion;
+  yamlTarget.set('version', newVersion);
+  
+  const url = `${config.env.ATOM_API_URL}/v1/service/fnet-node/publish`;
+
+  const publishResponse = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${access_token}`
+    },
+    body: JSON.stringify({
+      name: target.params.name,
+      version: target.params.version,
+      docs: target.params.docs,
+      configs: target.params.configs,
+    })
+  });
+
+  if (!publishResponse.ok) {
+    throw new Error(`Error publishing fnet node: ${publishResponse.statusText}`);
+  }
+
+  const publishData = await publishResponse.json();
+
+  if (publishData?.error) throw new Error('Error publishing fnet node.');
+
+  const upload_session_id = publishData?.upload.id;
+
+  let command = `fnet-dir-zipper`;
+  command += ` --sourceDir='${context.project.projectDir}'`;
+  command += ` --pattern=**/*`;
+  command += ` --stdout_format=json`;
+  
+  const shResult = await fnetShellJs(command);
+  if (shResult.code !== 0) throw new Error(shResult.stderr);
+
+  const zipData = JSON.parse(shResult.stdout);
+  const zipFilePath = zipData.path;
+
+  let formData = new FormData();
+  formData.append('file', fs.createReadStream(zipFilePath));
+
+  const uploadResponse = await fetch(`${config.env.ATOM_API_URL}/v1/service/upload/single/${upload_session_id}`, {
+    method: 'POST',
+    headers: {
+      ...formData.getHeaders(),
+      "Authorization": `Bearer ${access_token}`
+    },
+    body: formData
+  });
+
+  if (!uploadResponse.ok) {
+    throw new Error(`Error uploading fnet node: ${uploadResponse.statusText}`);
+  }
+
+  const uploadResult = await uploadResponse.json();
+
+  if (uploadResult?.error) throw new Error('Error uploading fnet node.');
+}
+
+export { deployToFnetNode as default };

package/dist/fnet/index.B90Vm9uq.js

@@ -0,0 +1,114 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import semver from 'semver';
+import fnetShellJs from '@fnet/shelljs';
+import fnetConfig from '@fnet/config';
+import fnetUpListFiles from '@fnet/up-list-files';
+import fnetObjectFromSchema from '@fnet/object-from-schema';
+import yaml from 'yaml';
+import { w as which } from './index.js';
+import { fileURLToPath } from 'node:url';
+import 'child_process';
+import '@fnet/prompt';
+import 'commander';
+import 'fs';
+import '@fnet/yaml';
+import '@fnet/shell-flow';
+import '@flownet/lib-render-templates-dir';
+import 'nunjucks';
+import 'lodash.clonedeep';
+import 'isobject';
+import 'redis';
+import '@flownet/lib-is-redis-online';
+import 'node:crypto';
+import '@flownet/lib-atom-api-js';
+import 'lodash.merge';
+import '@flownet/lib-parse-imports-js';
+import '@fnet/npm-list-versions';
+import '@fnet/npm-pick-versions';
+import 'object-hash';
+import 'ajv/dist/2020.js';
+import 'ajv/dist/standalone/index.js';
+import 'ajv-formats';
+import 'path';
+import '@flownet/lib-parse-node-url';
+import 'bpmn-moddle';
+import 'dagre';
+import '@fnet/expression';
+import 'chalk';
+import '@fnet/list-files';
+import '@fnet/key-value-transformer';
+import 'lodash.pick';
+import 'lodash.omit';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+async function deployToNpm({ atom, setProgress, context, deploymentProject, deploymentProjectTarget: target, yamlTarget }) {
+
+  await setProgress({ message: "Deploying it as npm package." });
+
+  const projectDir = context.projectDir;
+  const packageJSONPath = path.resolve(projectDir, 'package.json');
+
+  const packageJSONContent = fs.readFileSync(packageJSONPath);
+
+  const packageJSON = JSON.parse(packageJSONContent);
+
+  packageJSON.name = target.params.name;
+
+  packageJSON.version = semver.inc(target.version, "patch");
+
+  const binName = target.params.bin?.name || target.params.bin;
+  const binEnabled = target.params.bin?.enabled !== false;
+
+  if (binEnabled && binName && typeof binName === 'string') {
+    packageJSON.bin = {
+      [binName]: 'dist/cli/esm/index.js'
+    };
+  }
+
+  delete packageJSON.scripts;
+  delete packageJSON.devDependencies;
+
+  packageJSON.scripts = {
+    "serve": "npx serve ."
+  };
+
+  fs.writeFileSync(packageJSONPath, JSON.stringify(packageJSON, null, "\t"));
+
+  // TODO: improve this for all builders/deploys
+  const configName = target.config || "npm";
+  let npmConfig = (await fnetConfig({ name: configName, dir: context.projectDir, tags: context.tags, optional: true }))?.data;
+
+  if (!npmConfig) {
+    // create config from schema
+    const schemas = fnetUpListFiles({ dir: __dirname, pattern: '@fnet/cli-project-schemas/dist/schemas/to-npm.yaml', absolute: true });
+    if (schemas.length === 0) throw new Error('Couldnt find schema to create npm config');
+    const newConfig = await fnetObjectFromSchema({ schema: schemas[0], tags: context.tags });
+
+    const projectDir = context.project.projectDir;
+    const dotFnetDir = path.resolve(projectDir, '.fnet');
+    if (!fs.existsSync(dotFnetDir)) fs.mkdirSync(dotFnetDir);
+    fs.writeFileSync(path.resolve(dotFnetDir, `${configName}.fnet`), yaml.stringify(newConfig));
+    npmConfig = newConfig;
+  }
+
+  fs.writeFileSync(path.resolve(projectDir, '.npmrc'), `//registry.npmjs.org/:_authToken=${npmConfig.env.NPM_TOKEN}`);
+
+  if (target.dryRun === true) return;
+
+  const packageManager = which('bun') ? 'bun' : 'npm';
+
+  let result = await fnetShellJs(`${packageManager} publish --access public`, { cwd: projectDir });
+  if (result.code !== 0) throw new Error('Couldnt publish to npm');
+
+  // restore
+  fs.writeFileSync(packageJSONPath, packageJSONContent);
+
+  deploymentProject.isDirty = true;
+
+  target.version = packageJSON.version;
+  yamlTarget.set('version', packageJSON.version);
+}
+
+export { deployToNpm as default };

package/dist/fnet/index.BMsD46br.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import semver from 'semver';
+import fnetShellJs from '@fnet/shelljs';
+import fnetConfig from '@fnet/config';
+
+async function deployToGcs({ setProgress, context, deploymentProject, deploymentProjectTarget: target, registerToPackageManager, yamlTarget }) {
+
+  await setProgress({ message: "Deploying it as gcs package." });
+
+  const projectDir = context.projectDir;
+  const packageJSONPath = path.resolve(projectDir, 'package.json');
+
+  const packageJSONContent = fs.readFileSync(packageJSONPath);
+
+  const packageJSON = JSON.parse(packageJSONContent);
+
+  packageJSON.name = target.params.name;
+  packageJSON.version = semver.inc(target.version, "patch");
+
+  delete packageJSON.scripts;
+  delete packageJSON.devDependencies;
+
+  fs.writeFileSync(packageJSONPath, JSON.stringify(packageJSON, null, "\t"));
+
+  const { file: pmFile, data: gcsConfig } = await fnetConfig({
+    name: target.config || "gcs",
+    dir: context.projectDir,
+    tags: context.tags
+  });
+  
+  let command = `fnet-files-to-gcs`;
+  command += ` --projectId='${gcsConfig.env.GCS_PROJECT_ID}'`;
+  command += ` --bucketName='${gcsConfig.env.GCS_BUCKET_NAME}'`;
+  command += ` --keyFilename='${path.resolve(path.dirname(pmFile), gcsConfig.env.GCS_UPLOADER_KEY_FILE)}'`;
+  command += ` --dir='${projectDir}'`;
+  command += ` --pattern={'dist/**/**','bin/**/**','test/**/**','*.html'}`;
+  command += ` --destDir='${packageJSON.name}/${packageJSON.version}'`;
+  command += ` --metadata.cacheControl='public, max-age=31536000, immutable'`;
+  // command += ` --verbose`;
+
+  if (gcsConfig.env.DOMAIN) command += ` --domain='${gcsConfig.env.DOMAIN}'`;
+
+  if (target.dry_run === true || target.params.dry_run === true) command += ` --dryRun`;
+
+  await fnetShellJs(command);
+
+  // restore
+  fs.writeFileSync(packageJSONPath, packageJSONContent);
+
+  if (target.dryRun === true) return;
+
+  deploymentProject.isDirty = true;
+  target.version = packageJSON.version;
+  yamlTarget.set('version', packageJSON.version);
+
+  await registerToPackageManager({ target, packageJSON });
+}
+
+export { deployToGcs as default };

package/dist/fnet/index.BUhoGq-h.js

@@ -0,0 +1,70 @@
+import semver from 'semver';
+import fnetConfig from '@fnet/config';
+
+async function deployToFnetForm({ setProgress, context, deploymentProject, deploymentProjectTarget: target, yamlTarget }) {
+
+  await setProgress({ message: "Deploying it as fnet form." });
+
+  const { file: configFile, data: config } = await fnetConfig({
+    name: target.config || "fnet-form",
+    dir: context.projectDir,
+    tags: context.tags
+  });
+
+  if (!config.env.ATOM_API_URL) throw new Error(`ATOM_API_URL is required in ${configFile}`);
+  if (!config.env.ATOM_API_USERNAME) throw new Error(`ATOM_API_USERNAME is required in ${configFile}`);
+  if (!config.env.ATOM_API_PASSWORD) throw new Error(`ATOM_API_PASSWORD is required in ${configFile}`);
+
+  const apiTokenUrl = `${config.env.ATOM_API_URL}/v1/auth/token`;
+  const username = config.env.ATOM_API_USERNAME;
+  const password = config.env.ATOM_API_PASSWORD;
+
+  const tokenResponse = await fetch(apiTokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ username, password })
+  });
+
+  if (!tokenResponse.ok) {
+    throw new Error(`Failed to fetch token: ${tokenResponse.statusText}`);
+  }
+
+  const tokenData = await tokenResponse.json();
+  const access_token = tokenData?.access_token;
+
+  if (!access_token) throw new Error(`Invalid access_token from ${apiTokenUrl}`);
+
+  deploymentProject.isDirty = true;
+
+  const newVersion = semver.inc(target.version, "patch");
+  target.params.version = newVersion; // TODO: remove this line
+  target.version = newVersion;
+  yamlTarget.set('version', newVersion);
+  const url = `${config.env.ATOM_API_URL}/v1/service/fnet-form/publish`;
+
+  const publishResponse = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${access_token}`
+    },
+    body: JSON.stringify({
+      name: target.params.name,
+      version: target.params.version,
+      docs: target.params.docs,
+      configs: target.params.configs,
+    })
+  });
+
+  if (!publishResponse.ok) {
+    throw new Error(`Error publishing fnet form: ${publishResponse.statusText}`);
+  }
+
+  const publishData = await publishResponse.json();
+
+  if (publishData?.error) throw new Error('Error publishing fnet form.');
+}
+
+export { deployToFnetForm as default };

package/dist/fnet/index.BjzEMdm1.js

@@ -0,0 +1,52 @@
+import fnetConfig from '@fnet/config';
+import fnetDeploy from '@fnet/to-rust';
+import cloneDeep from 'lodash.clonedeep';
+import semver from 'semver';
+
+async function deployToRust({
+  atom,
+  target,
+  onProgress,
+  projectDir,
+  dependencies,
+  context,
+  yamlTarget
+}) {
+
+  const deployerName = 'Rust';
+
+  if (onProgress) await onProgress({ message: `Deploying it as ${deployerName} package.` });
+
+  const config = target?.config ? await fnetConfig({
+    name: target.config,
+    dir: projectDir,
+    optional: true,
+    transferEnv:false,
+    tags: context.tags
+  }) : undefined;
+
+  const nextVersion = semver.inc(target.version || "0.1.0", "patch");
+  target.params.version = nextVersion; // TODO: remove this line
+  target.version = nextVersion;
+  yamlTarget.set('version', nextVersion);
+
+  const params = cloneDeep(target.params);
+
+  params.dependencies = cloneDeep(dependencies);
+
+  const args = {
+    atom,
+    params,
+    config: config?.config,
+    src: projectDir,
+    dest: projectDir,
+  };
+
+  const result = await fnetDeploy(args);
+
+  return {
+    deployer: result,
+  };
+}
+
+export { deployToRust as default };

package/dist/fnet/index.C9zKEF61.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import semver from 'semver';
+import fnetShellJs from '@fnet/shelljs';
+import fnetConfig from '@fnet/config';
+
+async function deployToFnetPackage({ setProgress, context, deploymentProject, deploymentProjectTarget: target, yamlTarget }) {
+
+  await setProgress({ message: "Deploying it as fnet package." });
+
+  const projectDir = context.projectDir;
+  const packageJSONPath = path.resolve(projectDir, 'package.json');
+
+  const packageJSONContent = fs.readFileSync(packageJSONPath);
+
+  const packageJSON = JSON.parse(packageJSONContent);
+
+  packageJSON.name = target.params.name;
+  packageJSON.version = semver.inc(target.version, "patch");
+
+  delete packageJSON.scripts;
+  delete packageJSON.devDependencies;
+
+  fs.writeFileSync(packageJSONPath, JSON.stringify(packageJSON, null, "\t"));
+
+  const { file: configFile, data: config } = await fnetConfig({
+    name: target.config || "fnet-package",
+    dir: context.projectDir,
+    tags: context.tags
+  });
+
+
+  if (!config.env.ATOM_API_URL) throw new Error(`ATOM_API_URL is required in ${configFile}`);
+  if (!config.env.ATOM_API_USERNAME) throw new Error(`ATOM_API_USERNAME is required in ${configFile}`);
+  if (!config.env.ATOM_API_PASSWORD) throw new Error(`ATOM_API_PASSWORD is required in ${configFile}`);
+
+  const apiUrl = `${config.env.ATOM_API_URL}/v1/auth/token`;
+  const username = config.env.ATOM_API_USERNAME;
+  const password = config.env.ATOM_API_PASSWORD;
+
+  const tokenResponse = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ username, password })
+  });
+
+  if (!tokenResponse.ok) {
+    throw new Error(`Failed to fetch token: ${tokenResponse.statusText}`);
+  }
+
+  const tokenData = await tokenResponse.json();
+  const access_token = tokenData?.access_token;
+  if (!access_token) throw new Error(`Invalid access_token from ${apiUrl}`);
+
+  let command = `fnet-files-to-gcs`;
+  command += ` --projectId='${config.env.GCS_PROJECT_ID}'`;
+  command += ` --bucketName='${config.env.GCS_BUCKET_NAME}'`;
+  command += ` --keyFilename='${path.resolve(path.dirname(configFile), config.env.GCS_UPLOADER_KEY_FILE)}'`;
+  command += ` --dir='${projectDir}'`;
+  command += ` --pattern={'dist/**/**','bin/**/**','test/**/**','*.html'}`;
+  command += ` --destDir='${packageJSON.name}/${packageJSON.version}'`;
+  command += ` --metadata.cacheControl='public, max-age=31536000, immutable'`;
+  // command += ` --verbose`;
+
+  if (config.env.DOMAIN) command += ` --domain='${config.env.DOMAIN}'`;
+
+  if (target.dry_run === true || target.params.dry_run === true) command += ` --dryRun`;
+
+  await fnetShellJs(command);
+
+  // restore
+  fs.writeFileSync(packageJSONPath, packageJSONContent);
+
+  if (target.dryRun === true) return;
+
+  deploymentProject.isDirty = true;
+  target.version = packageJSON.version;
+  yamlTarget.set('version', packageJSON.version);
+
+  const url = `${config.env.ATOM_API_URL}/v1/service/fnet-package/publish`;
+  const publishResponse = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${access_token}`
+    },
+    body: JSON.stringify({
+      name: packageJSON.name,
+      version: packageJSON.version,
+      version_domain: config.env.DOMAIN,
+      docs: target.params.docs,
+      configs: target.params.configs,
+    })
+  });
+
+  if (!publishResponse.ok) {
+    throw new Error(`Failed to publish fnet package: ${publishResponse.statusText}`);
+  }
+
+  const publishData = await publishResponse.json();
+  if (publishData?.error) throw new Error("Failed to publish fnet package.");
+}
+
+export { deployToFnetPackage as default };

package/dist/fnet/index.CQNYMi1Z.js

@@ -0,0 +1,51 @@
+import fnetConfig from '@fnet/config';
+import fnetToElectron from '@flownet/lib-to-electron';
+import cloneDeep from 'lodash.clonedeep';
+import semver from 'semver';
+
+async function deployToElectron({
+  atom,
+  target,
+  onProgress,
+  projectDir,
+  dependencies,
+  context,
+  yamlTarget
+}) {
+
+  const deployerName = 'electron';
+
+  if (onProgress) await onProgress({ message: `Deploying it as ${deployerName} package.` });
+
+  const config = target?.config ? await fnetConfig({
+    name: target.config,
+    dir: projectDir,
+    optional: true,
+    transferEnv:false,
+    tags: context.tags
+  }) : undefined;
+
+  const nextVersion = semver.inc(target.version || "0.1.0", "patch");
+  target.version = nextVersion;
+  yamlTarget.set('version', nextVersion);
+
+  const params = cloneDeep(target.params);
+
+  params.dependencies = cloneDeep(dependencies);
+
+  const args = {
+    atom,
+    params,
+    config: config?.config,
+    src: projectDir,
+    dest: projectDir,
+  };
+
+  const result = await fnetToElectron(args);
+
+  return {
+    deployer: result,
+  };
+}
+
+export { deployToElectron as default };