autoforce 0.1.18 → 0.1.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/.autoforce.json CHANGED
@@ -1,5 +1,5 @@
1
1
  {
2
- "version": "0.1.18",
2
+ "version": "0.1.19",
3
3
  "backlogColumn": "Todo",
4
4
  "gitServices": "github",
5
5
  "gitModel": "githubflow",
package/CHANGELOG.md CHANGED
@@ -1,5 +1,15 @@
1
1
  # Versiones
2
2
 
3
+ ## Version 0.1.18
4
+ - Fecha:
5
+ - Paquete: [Descargar](https://www.npmjs.com/package/autoforce/v/0.1.18ra la placa
6
+
7
+ TIPO CASO: Tarea Programada SF Deploy 254 Core & Industry 4 h)
8
+ - Cambios:
9
+ * Reorganizar los modelos para que sea mas por la configuracion misma
10
+ - https://github.com/sebastianclaros/autoforce/issues/46
11
+
12
+
3
13
  ## Version 0.1.17
4
14
  - Fecha: 13 Dic 2024
5
15
  - Paquete: [Descargar](https://www.npmjs.com/package/autoforce/v/0.1.17)
package/lib/auto.js CHANGED
@@ -1,14 +1,5 @@
1
- var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
2
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
3
- return new (P || (P = Promise))(function (resolve, reject) {
4
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
5
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
6
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
7
- step((generator = generator.apply(thisArg, _arguments || [])).next());
8
- });
9
- };
10
1
  // Comandos validos
11
- import { createObject, validateTask, getTasks, helpTask, runTask } from "./helpers/tasks.js";
2
+ import { createObject, validateTask, getTasks, previewTask, helpTask, runTask } from "./helpers/tasks.js";
12
3
  import { logError } from "./helpers/color.js";
13
4
  import prompts from "prompts";
14
5
  import { createConfigurationFile, getConfigFile } from "./helpers/util.js";
@@ -21,48 +12,45 @@ const proxyCommand = {
21
12
  };
22
13
  const taskCommand = {
23
14
  'help': helpTask,
15
+ 'preview': previewTask,
24
16
  'task': runTask,
25
17
  'new': runTask,
26
18
  'subtask': runTask
27
19
  };
28
- function showVersion() {
29
- return __awaiter(this, void 0, void 0, function* () {
30
- const __dirname = dirname(fileURLToPath(import.meta.url));
31
- const version = getConfigFile(__dirname + '/../.autoforce.json', 'version', '0.1.14');
32
- console.log('AutoForce v' + version);
33
- return true;
34
- });
20
+ async function showVersion() {
21
+ const __dirname = dirname(fileURLToPath(import.meta.url));
22
+ const version = getConfigFile(__dirname + '/../.autoforce.json', 'version', '0.1.14');
23
+ console.log('AutoForce v' + version);
24
+ return true;
35
25
  }
36
- export default function main() {
37
- return __awaiter(this, void 0, void 0, function* () {
38
- try {
39
- const config = getConfigFromArgs(process.argv.slice(2));
40
- const taskCommandKeys = Object.keys(taskCommand);
41
- if (taskCommandKeys.includes(config.command)) {
42
- const tasks = getTasks(config.subfolder);
43
- const taskName = yield askForTaskName(config.taskName, tasks);
44
- if (taskName) {
45
- const task = tasks[taskName];
46
- context.options = config.arguments && task.arguments ? Object.assign(Object.assign({}, config.options), createObject(task.arguments, config.arguments)) : config.options;
47
- // Valida los json de task y subtask
48
- if (validateTask(task)) {
49
- yield taskCommand[config.command](task, context.options);
50
- }
51
- else {
52
- logError('Verifique que los json de task y subtask esten validos');
53
- }
26
+ export default async function main() {
27
+ try {
28
+ const config = getConfigFromArgs(process.argv.slice(2));
29
+ const taskCommandKeys = Object.keys(taskCommand);
30
+ if (taskCommandKeys.includes(config.command)) {
31
+ const tasks = getTasks(config.subfolder);
32
+ const taskName = await askForTaskName(config.taskName, tasks);
33
+ if (taskName) {
34
+ const task = tasks[taskName];
35
+ context.options = config.arguments && task.arguments ? { ...config.options, ...createObject(task.arguments, config.arguments) } : config.options;
36
+ // Valida los json de task y subtask
37
+ if (validateTask(task)) {
38
+ await taskCommand[config.command](task, context.options);
39
+ }
40
+ else {
41
+ logError('Verifique que los json de task y subtask esten validos');
54
42
  }
55
- }
56
- else {
57
- yield proxyCommand[config.command](config.taskName, config.options);
58
43
  }
59
44
  }
60
- catch (error) {
61
- if (error instanceof Error) {
62
- console.error(error.message);
63
- }
45
+ else {
46
+ await proxyCommand[config.command](config.taskName, config.options);
64
47
  }
65
- });
48
+ }
49
+ catch (error) {
50
+ if (error instanceof Error) {
51
+ console.error(error.message);
52
+ }
53
+ }
66
54
  }
67
55
  export function getConfigFromArgs(processArgs) {
68
56
  const config = { options: {}, taskName: '', command: '', subfolder: '', arguments: [] };
@@ -101,23 +89,21 @@ export function getConfigFromArgs(processArgs) {
101
89
  config.arguments = args;
102
90
  return config;
103
91
  }
104
- function askForTaskName(taskName, tasks) {
105
- return __awaiter(this, void 0, void 0, function* () {
106
- // Si exite lo devuelve
107
- if (tasks[taskName]) {
108
- return taskName;
109
- }
110
- // Sino pregunta
111
- const response = yield prompts({
112
- type: "select",
113
- name: "taskName",
114
- message: taskName
115
- ? `${taskName} no es un comando valido`
116
- : "Seleccione un comando",
117
- choices: Object.values(tasks).map((task) => {
118
- return { title: task.name, value: task.name, description: task.description };
119
- })
120
- });
121
- return response.taskName;
92
+ async function askForTaskName(taskName, tasks) {
93
+ // Si exite lo devuelve
94
+ if (tasks[taskName]) {
95
+ return taskName;
96
+ }
97
+ // Sino pregunta
98
+ const response = await prompts({
99
+ type: "select",
100
+ name: "taskName",
101
+ message: taskName
102
+ ? `${taskName} no es un comando valido`
103
+ : "Seleccione un comando",
104
+ choices: Object.values(tasks).map((task) => {
105
+ return { title: task.name, value: task.name, description: task.description };
106
+ })
122
107
  });
108
+ return response.taskName;
123
109
  }
@@ -1,5 +1,6 @@
1
1
  import { DocumentationModule } from "../types/auto.js";
2
2
  export declare function getClasses(files: string[]): string[];
3
+ export declare function executeClasses(items: string[], filename: string, folder: string): Promise<void>;
3
4
  declare const classModule: DocumentationModule;
4
5
  export default classModule;
5
6
  /**
@@ -1,12 +1,3 @@
1
- var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
2
- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
3
- return new (P || (P = Promise))(function (resolve, reject) {
4
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
5
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
6
- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
7
- step((generator = generator.apply(thisArg, _arguments || [])).next());
8
- });
9
- };
10
1
  import sf from "./connect.js";
11
2
  import { default as templateGenerator } from "./template.js";
12
3
  import { DICTIONARY_FOLDER, getModelFolders } from "./util.js";
@@ -18,18 +9,16 @@ function getTemplateEngine() {
18
9
  return _templateEngine;
19
10
  }
20
11
  import { sortByName, getNamesByExtension, verFecha, splitFilename } from "./util.js";
21
- function getMetadata(clases) {
22
- return __awaiter(this, void 0, void 0, function* () {
23
- try {
24
- yield sf.connect();
25
- const classRecords = yield sf.getClasses(clases);
26
- return Array.isArray(classRecords) ? classRecords : [classRecords];
27
- }
28
- catch (e) {
29
- console.error(e);
30
- }
31
- return [];
32
- });
12
+ async function getMetadata(clases) {
13
+ try {
14
+ await sf.connect();
15
+ const classRecords = await sf.getClasses(clases);
16
+ return Array.isArray(classRecords) ? classRecords : [classRecords];
17
+ }
18
+ catch (e) {
19
+ console.error(e);
20
+ }
21
+ return [];
33
22
  }
34
23
  export function getClasses(files) {
35
24
  const items = new Set();
@@ -134,71 +123,69 @@ function getInnerClasses(classes) {
134
123
  }
135
124
  return ret;
136
125
  }
137
- function executeClasses(items, filename, folder) {
138
- return __awaiter(this, void 0, void 0, function* () {
139
- const templateEngine = getTemplateEngine();
140
- if (items.length === 0) {
141
- return;
142
- }
143
- // Busca la metadata
144
- let contexts = yield getMetadata(items);
145
- if (!contexts || contexts.length === 0) {
146
- return;
147
- }
148
- // Arma el diccionario de cada Clase
149
- templateEngine.read("class");
150
- for (const context of contexts) {
151
- templateEngine.render(context, {
152
- helpers: {
153
- verFecha,
154
- modifiers,
155
- linkToType,
156
- classLinkGraph,
157
- filterByPublic,
158
- classAttributes,
159
- scopeModifiers
160
- }
161
- });
162
- templateEngine.save(context.Name, DICTIONARY_FOLDER + "/classes");
163
- }
164
- // Saca las innerClass y las pone como clases con namespace
165
- const innerClasses = getInnerClasses(contexts);
166
- const namespaces = {};
167
- if (innerClasses.length > 0) {
168
- templateEngine.read("class-inner");
169
- for (const context of innerClasses) {
170
- templateEngine.render(context, {
171
- helpers: { verFecha, modifiers, linkToType }
172
- });
173
- templateEngine.save(context.Name, DICTIONARY_FOLDER + "/classes/" + context.namespace);
174
- // arma un mapa de namespace con el array de sus innerclases
175
- if (context.namespace) {
176
- if (namespaces[context.namespace] === undefined) {
177
- namespaces[context.namespace] = [context.Name];
178
- }
179
- else {
180
- namespaces[context.namespace].push(context.Name);
181
- }
182
- }
183
- }
184
- contexts = contexts.concat(innerClasses);
185
- }
186
- // Arma el documento indice del grupo de clases
187
- contexts.sort(sortByName);
188
- templateEngine.read("classes");
189
- const classContext = { classes: contexts, namespaces };
190
- templateEngine.render(classContext, {
126
+ export async function executeClasses(items, filename, folder) {
127
+ const templateEngine = getTemplateEngine();
128
+ if (items.length === 0) {
129
+ return;
130
+ }
131
+ // Busca la metadata
132
+ let contexts = await getMetadata(items);
133
+ if (!contexts || contexts.length === 0) {
134
+ return;
135
+ }
136
+ // Arma el diccionario de cada Clase
137
+ templateEngine.read("class");
138
+ for (const context of contexts) {
139
+ templateEngine.render(context, {
191
140
  helpers: {
192
141
  verFecha,
193
142
  modifiers,
194
143
  linkToType,
195
- filterByPublic,
196
144
  classLinkGraph,
197
- classLink
145
+ filterByPublic,
146
+ classAttributes,
147
+ scopeModifiers
198
148
  }
199
149
  });
200
- templateEngine.save(filename, +"/" + folder);
150
+ templateEngine.save(context.Name, DICTIONARY_FOLDER + "/classes");
151
+ }
152
+ // Saca las innerClass y las pone como clases con namespace
153
+ const innerClasses = getInnerClasses(contexts);
154
+ const namespaces = {};
155
+ if (innerClasses.length > 0) {
156
+ templateEngine.read("class-inner");
157
+ for (const context of innerClasses) {
158
+ templateEngine.render(context, {
159
+ helpers: { verFecha, modifiers, linkToType }
160
+ });
161
+ templateEngine.save(context.Name, DICTIONARY_FOLDER + "/classes/" + context.namespace);
162
+ // arma un mapa de namespace con el array de sus innerclases
163
+ if (context.namespace) {
164
+ if (namespaces[context.namespace] === undefined) {
165
+ namespaces[context.namespace] = [context.Name];
166
+ }
167
+ else {
168
+ namespaces[context.namespace].push(context.Name);
169
+ }
170
+ }
171
+ }
172
+ contexts = contexts.concat(innerClasses);
173
+ }
174
+ // Arma el documento indice del grupo de clases
175
+ contexts.sort(sortByName);
176
+ templateEngine.read("classes");
177
+ const classContext = { classes: contexts, namespaces };
178
+ templateEngine.render(classContext, {
179
+ helpers: {
180
+ verFecha,
181
+ modifiers,
182
+ linkToType,
183
+ filterByPublic,
184
+ classLinkGraph,
185
+ classLink
186
+ }
201
187
  });
188
+ templateEngine.save(filename, +"/" + folder);
202
189
  }
203
190
  const classModule = {
204
191
  getItems: getClasses,