quackage 1.0.45 → 1.0.47

package/source/commands/Quackage-Command-PrepareDocs.js

@@ -0,0 +1,156 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+const libFS = require('fs');
+const libPath = require('path');
+
+class QuackageCommandPrepareDocs extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'prepare-docs';
+		this.options.Description = 'Prepare documentation: generate catalog, build keyword index and inject pict-docuserve assets.';
+
+		this.options.CommandArguments.push({ Name: '<docs_folder>', Description: 'The documentation folder to prepare.' });
+
+		this.options.CommandOptions.push({ Name: '-d, --directory_root [directory_root]', Description: 'Root directory to scan for modules (defaults to CWD).', Default: '' });
+		this.options.CommandOptions.push({ Name: '-b, --branch [branch]', Description: 'Git branch for GitHub raw URLs (defaults to master).', Default: 'master' });
+		this.options.CommandOptions.push({ Name: '-g, --github_org [github_org]', Description: 'GitHub organization for raw URLs (defaults to stevenvelozo).', Default: 'stevenvelozo' });
+
+		this.options.Aliases.push('docs');
+		this.options.Aliases.push('prep-docs');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		let tmpDocsFolder = libPath.resolve(this.ArgumentString || '.');
+		let tmpDirectoryRoot = this.CommandOptions.directory_root || this.fable.AppData.CWD;
+		let tmpBranch = this.CommandOptions.branch || 'master';
+		let tmpGitHubOrg = this.CommandOptions.github_org || 'stevenvelozo';
+
+		this.log.info(`Preparing documentation in [${tmpDocsFolder}]...`);
+
+		// Ensure the output folder exists
+		if (!libFS.existsSync(tmpDocsFolder))
+		{
+			this.log.info(`Creating documentation folder [${tmpDocsFolder}]...`);
+			libFS.mkdirSync(tmpDocsFolder, { recursive: true });
+		}
+
+		// Find the executables we need
+		let tmpIndoctrinateLocation = this.resolveExecutable('indoctrinate');
+		if (!tmpIndoctrinateLocation)
+		{
+			return fCallback(new Error(`Could not find indoctrinate.  Make sure it is installed (npm install indoctrinate).`));
+		}
+
+		let tmpDocuserveLocation = this.resolveExecutable('pict-docuserve');
+		if (!tmpDocuserveLocation)
+		{
+			return fCallback(new Error(`Could not find pict-docuserve.  Make sure it is installed (npm install pict-docuserve).`));
+		}
+
+		let tmpCatalogFile = libPath.join(tmpDocsFolder, 'retold-catalog.json');
+		let tmpKeywordIndexFile = libPath.join(tmpDocsFolder, 'retold-keyword-index.json');
+
+		let tmpAnticipate = this.fable.newAnticipate();
+
+		// Step 1: Generate the documentation catalog
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				this.log.info(`###############################[ STEP 1: INDOCTRINATE CATALOG ]###############################`);
+				this.fable.QuackageProcess.execute(
+					tmpIndoctrinateLocation,
+					[
+						'generate_catalog',
+						'-d', tmpDirectoryRoot,
+						'-o', tmpCatalogFile,
+						'-b', tmpBranch,
+						'-g', tmpGitHubOrg
+					],
+					{ cwd: this.fable.AppData.CWD },
+					fNext
+				);
+			}.bind(this));
+
+		// Step 2: Generate the keyword search index
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				this.log.info(`###############################[ STEP 2: KEYWORD INDEX ]###############################`);
+				this.fable.QuackageProcess.execute(
+					tmpIndoctrinateLocation,
+					[
+						'generate_keyword_index',
+						'-d', tmpDirectoryRoot,
+						'-o', tmpKeywordIndexFile
+					],
+					{ cwd: this.fable.AppData.CWD },
+					fNext
+				);
+			}.bind(this));
+
+		// Step 3: Inject pict-docuserve assets
+		tmpAnticipate.anticipate(
+			function (fNext)
+			{
+				this.log.info(`###############################[ STEP 3: DOCUSERVE INJECT ]###############################`);
+				this.fable.QuackageProcess.execute(
+					tmpDocuserveLocation,
+					[
+						'inject',
+						tmpDocsFolder
+					],
+					{ cwd: this.fable.AppData.CWD },
+					fNext
+				);
+			}.bind(this));
+
+		return tmpAnticipate.wait(
+			function (pError)
+			{
+				if (pError)
+				{
+					this.log.error(`Documentation preparation failed: ${pError.message}`);
+					return fCallback(pError);
+				}
+
+				// Ensure .nojekyll exists for GitHub Pages compatibility
+				let tmpNoJekyllPath = libPath.join(tmpDocsFolder, '.nojekyll');
+				libFS.writeFileSync(tmpNoJekyllPath, '');
+				this.log.info(`Wrote .nojekyll to [${tmpNoJekyllPath}]`);
+
+				this.log.info(`Documentation preparation complete!`);
+				this.log.info(`  Catalog: ${tmpCatalogFile}`);
+				this.log.info(`  Keyword Index: ${tmpKeywordIndexFile}`);
+				this.log.info(`  Docuserve assets injected into: ${tmpDocsFolder}`);
+
+				return fCallback();
+			}.bind(this));
+	}
+
+	resolveExecutable(pName)
+	{
+		let tmpLocations =
+			[
+				`${this.fable.AppData.CWD}/node_modules/.bin/${pName}`,
+				`${__dirname}/../../../.bin/${pName}`,
+				`${__dirname}/../../node_modules/.bin/${pName}`
+			];
+
+		for (let i = 0; i < tmpLocations.length; i++)
+		{
+			if (libFS.existsSync(tmpLocations[i]))
+			{
+				return tmpLocations[i];
+			}
+		}
+
+		return false;
+	}
+}
+
+module.exports = QuackageCommandPrepareDocs;

package/source/commands/Quackage-Command-RunMochaTests.js

@@ -9,12 +9,10 @@ class QuackageCommandBuild extends libCommandLineCommand
 
 		this.options.CommandKeyword = 'run-mocha-tests';
 		this.options.Description = 'Run mocha tests in your tests/ folder.';
+		this.options.Aliases.push('test');
 
 		this.options.CommandOptions.push({ Name: '-g, --grep [search_expression]', Description: 'A grep search expression for the subset of tests you want to run.' });
 
-		this.options.Aliases.push('test');
-
-		// Auto add the command on initialization
 		this.addCommand();
 	}
 

package/source/commands/Quackage-Command-UpdatePackage-Luxury.js

@@ -9,6 +9,7 @@ class QuackageCommandUpdatePackage extends libCommandLineCommand
 
 		this.options.CommandKeyword = 'luxuryupdatepackage';
 		this.options.Description = 'Update your package.json to build and run luxury code containers';
+		this.options.Aliases.push('luxury_update_package');
 
 		this.fable.TemplateProvider.addTemplate('PrototypePackage', JSON.stringify(this.pict.ProgramConfiguration, null, 4));
 
@@ -16,7 +17,6 @@ class QuackageCommandUpdatePackage extends libCommandLineCommand
 
 		this.options.Aliases.push('lux');
 
-		// Auto add the command on initialization
 		this.addCommand();
 	}
 

package/source/commands/Quackage-Command-UpdatePackage.js

@@ -9,12 +9,12 @@ class QuackageCommandUpdatePackage extends libCommandLineCommand
 
 		this.options.CommandKeyword = 'updatepackage';
 		this.options.Description = 'Update your package.json to support streamlined testing, building and coverage';
+		this.options.Aliases.push('update_package');
 
 		this.fable.TemplateProvider.addTemplate('PrototypePackage', JSON.stringify(this.pict.ProgramConfiguration, null, 4));
 
 		this.options.CommandOptions.push({ Name: '-f, --force', Description: 'Force overwrite anything in the package.json; use at your own quacking peril' });
 
-		// Auto add the command on initialization
 		this.addCommand();
 	}
 

package/source/commands/stricture/Quackage-Command-Stricture-Compile.js

@@ -0,0 +1,37 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+const libFS = require('fs');
+const libPath = require('path');
+
+class QuackageCommandStrictureCompile extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'stricture-compile';
+		this.options.Description = 'Compile stricture ddl into a meadow schema file.';
+
+		this.options.CommandArguments.push({ Name: '<output_folder>', Description: 'The folder in which to generate content' });
+
+		this.options.CommandOptions.push({ Name: '-m, --markdown [markdown_documentation_folder]', Description: 'Folder with markdwon documentation; subfolders are okay.', Default: '' });
+
+		this.options.Aliases.push('scomp');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		const libFilePersistence = this.services.FilePersistence;
+
+		const tmpOperationState = {};
+		tmpOperationState.RawOutputFolderPath = this.ArgumentString;
+
+		tmpOperationState.RawSourceCodeFolder = this.CommandOptions.source;
+
+		return fCallback();
+	};
+}
+
+module.exports = QuackageCommandStrictureCompile;

package/source/commands/stricture/Quackage-Command-StrictureLegacy.js

@@ -0,0 +1,37 @@
+const libCommandLineCommand = require('pict-service-commandlineutility').ServiceCommandLineCommand;
+
+const libFS = require('fs');
+const libPath = require('path');
+
+class QuackageCommandStrictureLegacy extends libCommandLineCommand
+{
+	constructor(pFable, pManifest, pServiceHash)
+	{
+		super(pFable, pManifest, pServiceHash);
+
+		this.options.CommandKeyword = 'stricture-legaacy';
+		this.options.Description = 'Run a legacy stricture command.';
+
+		this.options.CommandArguments.push({ Name: '<output_folder>', Description: 'The folder in which to generate content' });
+
+		this.options.CommandOptions.push({ Name: '-m, --markdown [markdown_documentation_folder]', Description: 'Folder with markdwon documentation; subfolders are okay.', Default: '' });
+
+		this.options.Aliases.push('str');
+
+		this.addCommand();
+	}
+
+	onRunAsync(fCallback)
+	{
+		const libFilePersistence = this.services.FilePersistence;
+
+		const tmpOperationState = {};
+		tmpOperationState.RawOutputFolderPath = this.ArgumentString;
+
+		tmpOperationState.RawSourceCodeFolder = this.CommandOptions.source;
+
+		return fCallback();
+	};
+}
+
+module.exports = QuackageCommandStrictureLegacy;

package/source/commands/stricture/services/Fable-Service-Stricture-Compile.js

@@ -0,0 +1,327 @@
+// Eventually to be moved to the stricture package
+
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+var libFS = require('fs');
+var libPath = require('path');
+var libLineReader = require('line-by-line');
+var libJSONFile = require('jsonfile');
+var libUnderscore = require('underscore');
+var libAsync = require('async');
+
+/**
+* Stricture MicroDDL Compiler
+*/
+
+// ## Load the default state for meadow and pict configuration settings
+var _DefaultAPIDefinitions = require(__dirname + '/Meadow-Endpoints-Definition-Defaults.js')
+var _DefaultAPISecurity = require(__dirname + '/Meadow-Endpoints-Security-Defaults.js');
+
+var _DefaultPict = require(__dirname + '/Pict-Configuration-Defaults.js');
+
+
+const _DefaultOptions = (
+	{
+	});
+
+class StrictureCompiler extends libFableServiceProviderBase
+{
+	/**
+	 * @param {import('fable')} pFable - The fable instance.
+	 * @param {Object<String, any>} [pOptions] - The options for the client.
+	 * @param {String} [pServiceHash] - A service hash for the fable service.
+	 */
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		let tmpOptions = Object.assign({}, _DefaultOptions, pOptions);
+		super(pFable, tmpOptions, pServiceHash);
+	}
+
+	GenerateMeadowSchema(pModelData)
+	{
+		var tmpTable = pModelData;
+
+		console.log('  > Table: ' + tmpTable.TableName);
+
+		var tmpPrimaryKey = 'ID' + tmpTable.TableName;
+
+		// Get the primary key
+		for (var j = 0; j < tmpTable.Columns.length; j++)
+			if (tmpTable.Columns[j].DataType == 'ID')
+				tmpPrimaryKey = tmpTable.Columns[j].Column;
+
+		var tmpModel = ({
+			Scope: tmpTable.TableName,
+			DefaultIdentifier: tmpPrimaryKey,
+
+			Domain: (typeof (tmpTable.Domain) === 'undefined') ? 'Default' : tmpTable.Domain,
+
+			Schema: [],
+
+			DefaultObject: {},
+
+			JsonSchema: ({
+				title: tmpTable.TableName,
+				type: 'object',
+				properties: {},
+				required: []
+			}),
+
+			Authorization: {}
+		});
+		for (var j = 0; j < tmpTable.Columns.length; j++)
+		{
+			var tmpColumnName = tmpTable.Columns[j].Column;
+			var tmpColumnType = tmpTable.Columns[j].DataType;
+			var tmpColumnSize = tmpTable.Columns[j].hasOwnProperty('Size') ? tmpTable.Columns[j].Size : 'Default';
+
+			var tmpSchemaEntry = { Column: tmpColumnName, Type: 'Default' };
+			// Dump out each column......
+			switch (tmpColumnType)
+			{
+				case 'ID':
+					tmpSchemaEntry.Type = 'AutoIdentity';
+					tmpModel.DefaultObject[tmpColumnName] = 0;
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'integer', size: tmpColumnSize };
+					tmpModel.JsonSchema.required.push(tmpColumnName);
+					break;
+				case 'GUID':
+					tmpSchemaEntry.Type = 'AutoGUID';
+					tmpModel.DefaultObject[tmpColumnName] = '0x0000000000000000';
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'string', size: tmpColumnSize };
+					break;
+				case 'ForeignKey':
+					tmpSchemaEntry.Type = 'Integer';
+					tmpModel.DefaultObject[tmpColumnName] = 0;
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'integer', size: tmpColumnSize };
+					tmpModel.JsonSchema.required.push(tmpColumnName);
+					break;
+				case 'Numeric':
+					tmpSchemaEntry.Type = 'Integer';
+					tmpModel.DefaultObject[tmpColumnName] = 0;
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'integer', size: tmpColumnSize };
+					break;
+				case 'Decimal':
+					tmpSchemaEntry.Type = 'Decimal';
+					tmpModel.DefaultObject[tmpColumnName] = 0.0;
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'number', size: tmpColumnSize };
+					break;
+				case 'String':
+				case 'Text':
+					tmpSchemaEntry.Type = 'String';
+					tmpModel.DefaultObject[tmpColumnName] = '';
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'string', size: tmpColumnSize };
+					break;
+				case 'DateTime':
+					tmpSchemaEntry.Type = 'DateTime';
+					tmpModel.DefaultObject[tmpColumnName] = null;
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'string', size: tmpColumnSize };
+					break;
+				case 'Boolean':
+					tmpSchemaEntry.Type = 'Boolean';
+					tmpModel.DefaultObject[tmpColumnName] = false;
+					tmpModel.JsonSchema.properties[tmpColumnName] = { type: 'boolean', size: tmpColumnSize };
+					break;
+			}
+			// Now mark up the magic columns that branch by name
+			switch (tmpColumnName)
+			{
+				case 'CreateDate':
+					tmpSchemaEntry.Type = 'CreateDate';
+					break;
+				case 'CreatingIDUser':
+					tmpSchemaEntry.Type = 'CreateIDUser';
+					break;
+				case 'UpdateDate':
+					tmpSchemaEntry.Type = 'UpdateDate';
+					break;
+				case 'UpdatingIDUser':
+					tmpSchemaEntry.Type = 'UpdateIDUser';
+					break;
+				case 'DeleteDate':
+					tmpSchemaEntry.Type = 'DeleteDate';
+					break;
+				case 'DeletingIDUser':
+					tmpSchemaEntry.Type = 'DeleteIDUser';
+					break;
+				case 'Deleted':
+					tmpSchemaEntry.Type = 'Deleted';
+					break;
+			}
+			tmpSchemaEntry.Size = tmpColumnSize;
+
+			// Now add it to the array
+			tmpModel.Schema.push(tmpSchemaEntry);
+		}
+
+		return tmpModel
+	}
+
+	/***********
+	 * MicroDDL Compiler
+	 *
+	 *****/
+	compileMicroDDL(pFilePath, pFileName, fCallback)
+	{
+		pFable = this.fable;
+
+		var tmpStrictureModelFile = pFable.settings.OutputLocation + pFable.settings.OutputFileName + '.json';
+		var tmpStrictureModelExtendedFile = pFable.settings.OutputLocation + pFable.settings.OutputFileName + '-Extended.json';
+		var tmpStrictureModelPICTFile = pFable.settings.OutputLocation + pFable.settings.OutputFileName + '-PICT.json';
+
+		var tmpCallback = (typeof (fCallback) === 'function') ? fCallback : () => { };
+
+		pFable.Stricture = (
+			{
+				// This hash table will hold the model
+				Tables: {},
+
+				// This array will hold the order for the tables in the model, so they match the order they are first introduced to Stricture
+				TablesSequence: [],
+
+				// This hash table will hold the authenticator configuration for the entire model
+				Authorization: {},
+
+				// This hash table will hold the meadow endpoint configuration for the entire model
+				Endpoints: {},
+
+				Pict: {}
+			}
+		);
+
+		console.info('--> Compiling MicroDDL to JSON');
+		console.log('  > Input file:  ' + pFable.settings.InputFileName);
+		console.log('  > Output file: ' + tmpStrictureModelFile);
+		console.log('  > Extended Output file: ' + tmpStrictureModelExtendedFile);
+
+		// Read in the file
+		console.info('  > Reading DDL File(s)');
+		ReadMicroDDLFile(pFable, pFable.settings.InputFileName,
+			function ()
+			{
+				libAsync.waterfall(
+					[
+						(fStageComplete) =>
+						{
+							// Generate the output
+							console.info('  > Metacompiling the Model');
+							libJSONFile.writeFile(tmpStrictureModelFile,
+								{ Tables: pFable.Stricture.Tables },
+								{ spaces: 4 },
+								function (pError)
+								{
+									if (pError)
+									{
+										console.error('  > Error writing out model JSON: ' + pError);
+									}
+									else
+									{
+										console.info('  > Model JSON Successfully Written');
+									}
+									return fStageComplete(pError);
+								}
+							);
+						},
+						(fStageComplete) =>
+						{
+							console.info(' Auto-generating inline meadow schemas');
+							for (var tmpTableKey in pFable.Stricture.Tables)
+							{
+								var tmpTable = pFable.Stricture.Tables[tmpTableKey];
+								var tmpSchema = GenerateMeadowSchema(tmpTable);
+								pFable.Stricture.Tables[tmpTableKey].MeadowSchema = tmpSchema;
+							}
+							return fStageComplete();
+						},
+						(fStageComplete) =>
+						{
+							// Generate the output
+							console.info('  > Compiling the Extended Model');
+							// Decorate the current model with the right output
+							if (typeof (pFable.Stricture) === 'object')
+							{
+								if (pFable.Stricture.hasOwnProperty('Tables') && (typeof (pFable.Stricture) === 'object'))
+								{
+									let tmpTableList = Object.keys(pFable.Stricture.Tables);
+									for (let i = 0; i < tmpTableList.length; i++)
+									{
+										const tmpTableName = tmpTableList[i];
+										const tmpTableObject = pFable.Stricture.Tables[tmpTableName];
+										// For now, have duplicate data in the schema.
+										let tmpJSONSchemaInsert;
+										try
+										{
+											tmpJSONSchemaInsert = JSON.parse(JSON.stringify(tmpTableObject));
+										}
+										catch (pError)
+										{
+											pFable.log.info(`Error parsing JSON for table: ${tmpTableName} -- ${pError}`)
+										}
+										// Remove the JSON Schema from the JSON Schema insert of the meadow model
+										delete tmpJSONSchemaInsert.JsonSchema;
+										// Add the JSON Schema to the model JSONSchema
+										tmpTableObject.MeadowSchema.JsonSchema.MeadowSchema = tmpJSONSchemaInsert;
+
+									}
+								}
+							}
+							libJSONFile.writeFile(tmpStrictureModelExtendedFile,
+								pFable.Stricture,
+								{ spaces: 4 },
+								function (pError)
+								{
+									if (pError)
+									{
+										console.error('  > Error writing out Extended model JSON: ' + pError);
+									}
+									else
+									{
+										console.info('  > Extended Model JSON Successfully Written');
+									}
+									return fStageComplete(pError);
+								}
+							);
+						},
+						(fStageComplete) =>
+						{
+							// Generate the output
+							console.info('  > Compiling the PICT Definition');
+							libJSONFile.writeFile(tmpStrictureModelPICTFile,
+								pFable.Stricture.Pict,
+								{ spaces: 4 },
+								function (pError)
+								{
+									if (pError)
+									{
+										console.error('  > Error writing out PICT model JSON: ' + pError);
+									}
+									else
+									{
+										console.info('  > PICT JSON Successfully Written');
+									}
+									return fStageComplete(pError);
+								}
+							);
+						}
+					],
+					(pError) =>
+					{
+						if (pError)
+						{
+							console.error('  > ERROR Compiling DDL: ' + pError);
+						}
+						else
+						{
+							console.info('  > DDL Compile Stages completed successfully.');
+						}
+
+						return tmpCallback(pError);
+					}
+				)
+			}
+		);
+	}
+}
+
+module.exports = StrictureCompiler;
+module.exports.default_configuration = _DefaultOptions;

package/templates/fableservice/{Fable-Service.js → Fable-Service-QUACKAGESCOPE.js}

@@ -1,10 +1,10 @@
-const FableServiceProviderBase = require('fable-serviceproviderbase');
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
 
 const _DefaultOptions = (
 	{
 	});
 
-class FableService extends FableServiceProviderBase
+class FableService{~PascalCaseIdentifier:Record.Scope~} extends libFableServiceProviderBase
 {
 	/**
 	 * @param {import('fable')} pFable - The fable instance.
@@ -13,7 +13,7 @@ class FableService extends FableServiceProviderBase
 	 */
 	constructor(pFable, pOptions, pServiceHash)
 	{
-		let tmpOptions = Object.assign({}, _DefaultOptions, pOptions);
+		const tmpOptions = Object.assign({}, _DefaultOptions, pOptions);
 		super(pFable, tmpOptions, pServiceHash);
 	}
 
@@ -23,6 +23,5 @@ class FableService extends FableServiceProviderBase
 	}
 }
 
-module.exports = FableService;
-
+module.exports = FableService{~PascalCaseIdentifier:Record.Scope~};
 module.exports.default_configuration = _DefaultOptions;