retold-data-service 2.0.12 → 2.0.14

package/source/services/migration-manager/Retold-Data-Service-MigrationManager.js

@@ -0,0 +1,357 @@
+/**
+ * Retold Data Service - Migration Manager Service
+ *
+ * Fable service that exposes meadow-migrationmanager capabilities via REST
+ * endpoints.  Creates an isolated MeadowMigrationManager instance (extends
+ * Pict) and instantiates all migration-manager services on it.
+ *
+ * Two route groups:
+ *   connectRoutes()      — JSON API endpoints under /api/*
+ *   connectWebUIRoutes() — Web UI HTML + /lib/* static JS libraries
+ *
+ * @author Steven Velozo <steven@velozo.com>
+ */
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libFs = require('fs');
+const libPath = require('path');
+
+const libMeadowMigrationManager = require('meadow-migrationmanager');
+
+class RetoldDataServiceMigrationManager extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'RetoldDataServiceMigrationManager';
+
+		// Create an isolated MeadowMigrationManager instance (extends Pict).
+		// This keeps migration-manager state completely separate from the
+		// main Fable context.
+		this._MM = new libMeadowMigrationManager(
+			{
+				Product: 'RetoldDataServiceMigrationManager',
+				LogStreams: pFable.settings.LogStreams || [{ streamtype: 'console' }]
+			});
+
+		// Instantiate migration-manager services on the isolated context
+		this._schemaLibrary = this._MM.instantiateServiceProvider('SchemaLibrary');
+		this._strictureAdapter = this._MM.instantiateServiceProvider('StrictureAdapter');
+		this._schemaVisualizer = this._MM.instantiateServiceProvider('SchemaVisualizer');
+		this._schemaDiff = this._MM.instantiateServiceProvider('SchemaDiff');
+		this._migrationGenerator = this._MM.instantiateServiceProvider('MigrationGenerator');
+		this._flowDataBuilder = this._MM.instantiateServiceProvider('FlowDataBuilder');
+		this._connectionLibrary = this._MM.instantiateServiceProvider('ConnectionLibrary');
+		this._databaseProviderFactory = this._MM.instantiateServiceProvider('DatabaseProviderFactory');
+	}
+
+	/**
+	 * The underlying MeadowMigrationManager (Pict) instance.
+	 */
+	get migrationManager()
+	{
+		return this._MM;
+	}
+
+	/**
+	 * The route prefix for all migration manager endpoints.
+	 */
+	get routePrefix()
+	{
+		let tmpConfig = this.fable.RetoldDataService.options.MigrationManager || {};
+		return tmpConfig.RoutePrefix || '';
+	}
+
+	/**
+	 * The model path for DDL files.
+	 */
+	get modelPath()
+	{
+		let tmpMigrationManagerConfig = this.fable.RetoldDataService.options.MigrationManager || {};
+		return tmpMigrationManagerConfig.ModelPath || false;
+	}
+
+	// ================================================================
+	// Helper functions (from MigrationManager-Server-Setup.js)
+	// ================================================================
+
+	/**
+	 * Scan a directory for DDL files (.mddl and .ddl) non-recursively.
+	 *
+	 * @param {string} pDirPath - Directory path to scan
+	 * @return {Array<string>} Array of absolute file paths
+	 */
+	scanForDDLFiles(pDirPath)
+	{
+		let tmpFiles = [];
+
+		try
+		{
+			let tmpEntries = libFs.readdirSync(pDirPath);
+
+			for (let i = 0; i < tmpEntries.length; i++)
+			{
+				let tmpEntry = tmpEntries[i];
+
+				if (tmpEntry.endsWith('.mddl') || tmpEntry.endsWith('.ddl'))
+				{
+					tmpFiles.push(libPath.join(pDirPath, tmpEntry));
+				}
+			}
+		}
+		catch (pError)
+		{
+			// Directory read failed; return empty
+		}
+
+		return tmpFiles;
+	}
+
+	/**
+	 * Normalize a compiled schema's Tables property from hash to array.
+	 *
+	 * @param {Object} pCompiledSchema - A compiled schema object
+	 * @return {Object} Schema with Tables normalized to array format
+	 */
+	normalizeSchemaForDiff(pCompiledSchema)
+	{
+		if (!pCompiledSchema || !pCompiledSchema.Tables)
+		{
+			return { Tables: [] };
+		}
+
+		if (Array.isArray(pCompiledSchema.Tables))
+		{
+			return pCompiledSchema;
+		}
+
+		let tmpNormalized = Object.assign({}, pCompiledSchema);
+		let tmpTables = [];
+		let tmpTableKeys = Object.keys(pCompiledSchema.Tables);
+
+		for (let i = 0; i < tmpTableKeys.length; i++)
+		{
+			tmpTables.push(pCompiledSchema.Tables[tmpTableKeys[i]]);
+		}
+
+		tmpNormalized.Tables = tmpTables;
+		return tmpNormalized;
+	}
+
+	/**
+	 * Recursively discover all DDL files referenced by [Include ...] directives.
+	 *
+	 * @param {string} pFilePath - Absolute path to the DDL file to parse
+	 * @param {string} pBaseDir  - The base model directory for relative path calculation
+	 * @param {Set}    [pVisited] - Set of already-visited absolute paths
+	 * @param {string} [pIncludedBy] - Relative path of the file that included this one
+	 * @param {number} [pDepth] - Include depth level
+	 * @return {Array<Object>} Array of file descriptor objects
+	 */
+	discoverIncludedFiles(pFilePath, pBaseDir, pVisited, pIncludedBy, pDepth)
+	{
+		let tmpVisited = pVisited || new Set();
+		let tmpResults = [];
+		let tmpDepth = pDepth || 0;
+
+		let tmpAbsPath = libPath.resolve(pFilePath);
+		let tmpAbsBase = libPath.resolve(pBaseDir);
+
+		// Prevent directory traversal outside base dir
+		if (!tmpAbsPath.startsWith(tmpAbsBase))
+		{
+			return tmpResults;
+		}
+
+		// Prevent circular includes
+		if (tmpVisited.has(tmpAbsPath))
+		{
+			return tmpResults;
+		}
+
+		tmpVisited.add(tmpAbsPath);
+
+		let tmpContent = '';
+		try
+		{
+			tmpContent = libFs.readFileSync(tmpAbsPath, 'utf8');
+		}
+		catch (pError)
+		{
+			return tmpResults;
+		}
+
+		let tmpRelPath = libPath.relative(tmpAbsBase, tmpAbsPath);
+
+		tmpResults.push(
+		{
+			RelativePath: tmpRelPath,
+			AbsolutePath: tmpAbsPath,
+			Content: tmpContent,
+			IsMain: (tmpVisited.size === 1),
+			IncludedBy: pIncludedBy || null,
+			Depth: tmpDepth
+		});
+
+		// Parse [Include ...] directives
+		let tmpLines = tmpContent.split('\n');
+		let tmpFileDir = libPath.dirname(tmpAbsPath);
+
+		for (let i = 0; i < tmpLines.length; i++)
+		{
+			let tmpLine = tmpLines[i].trim();
+			let tmpMatch = tmpLine.match(/^\[Include\s+(.+)\]$/i);
+
+			if (tmpMatch)
+			{
+				let tmpIncludePath = tmpMatch[1].trim();
+				let tmpIncludeAbs = libPath.resolve(tmpFileDir, tmpIncludePath);
+
+				let tmpChildFiles = this.discoverIncludedFiles(tmpIncludeAbs, tmpAbsBase, tmpVisited, tmpRelPath, tmpDepth + 1);
+
+				for (let j = 0; j < tmpChildFiles.length; j++)
+				{
+					tmpResults.push(tmpChildFiles[j]);
+				}
+			}
+		}
+
+		return tmpResults;
+	}
+
+	// ================================================================
+	// Initialization
+	// ================================================================
+
+	/**
+	 * Initialize the migration manager: scan ModelPath for DDL files,
+	 * import them into the SchemaLibrary, and auto-compile.
+	 *
+	 * @param {function} fCallback - Callback(pError)
+	 */
+	initializeMigrationManager(fCallback)
+	{
+		let tmpModelPath = this.modelPath;
+
+		if (!tmpModelPath)
+		{
+			this.fable.log.info('MigrationManager: No ModelPath configured; schema library is empty.');
+			return fCallback();
+		}
+
+		// Scan for DDL files
+		let tmpDDLFiles = this.scanForDDLFiles(tmpModelPath);
+		let tmpImportCount = 0;
+
+		for (let i = 0; i < tmpDDLFiles.length; i++)
+		{
+			this._schemaLibrary.importSchemaFromFile(tmpDDLFiles[i],
+				(pError, pEntry) =>
+				{
+					if (!pError && pEntry)
+					{
+						tmpImportCount++;
+					}
+				});
+		}
+
+		this.fable.log.info(`MigrationManager: Imported ${tmpImportCount} schema(s) from ${tmpModelPath}`);
+
+		// Auto-compile all imported schemas
+		let tmpSchemaNames = this._schemaLibrary.listSchemas();
+		let tmpCompilesPending = tmpSchemaNames.length;
+		let tmpCompilesDone = 0;
+
+		let fOnAllCompiled = () =>
+		{
+			this.fable.log.info(`MigrationManager: Compiled ${tmpCompilesDone} of ${tmpSchemaNames.length} schema(s).`);
+			return fCallback();
+		};
+
+		if (tmpSchemaNames.length === 0)
+		{
+			return fCallback();
+		}
+
+		for (let i = 0; i < tmpSchemaNames.length; i++)
+		{
+			let tmpSchemaName = tmpSchemaNames[i];
+			let tmpSchemaEntry = this._schemaLibrary.getSchema(tmpSchemaName);
+
+			if (!tmpSchemaEntry || !tmpSchemaEntry.DDL)
+			{
+				tmpCompilesPending--;
+				if (tmpCompilesPending <= 0)
+				{
+					fOnAllCompiled();
+				}
+				continue;
+			}
+
+			let tmpCompileCallback = (pError, pCompiledSchema, pMeadowPackages) =>
+				{
+					if (!pError && pCompiledSchema)
+					{
+						tmpSchemaEntry.CompiledSchema = pCompiledSchema;
+						tmpSchemaEntry.MeadowPackages = pMeadowPackages;
+						tmpSchemaEntry.LastCompiled = new Date().toJSON();
+						tmpCompilesDone++;
+					}
+					else if (pError)
+					{
+						this._MM.log.warn(`MigrationManager: Failed to compile schema [${tmpSchemaName}]: ${pError.message || pError}`);
+					}
+
+					tmpCompilesPending--;
+					if (tmpCompilesPending <= 0)
+					{
+						fOnAllCompiled();
+					}
+				};
+
+			if (tmpSchemaEntry.SourceFilePath)
+			{
+				this._strictureAdapter.compileFileAndGenerate(tmpSchemaEntry.SourceFilePath, tmpCompileCallback);
+			}
+			else
+			{
+				this._strictureAdapter.compileAndGenerate(tmpSchemaEntry.DDL, tmpCompileCallback);
+			}
+		}
+	}
+
+	// ================================================================
+	// Route registration
+	// ================================================================
+
+	/**
+	 * Register all migration manager API routes on the Orator service server.
+	 *
+	 * @param {Object} pOratorServiceServer - The Orator ServiceServer instance
+	 */
+	connectRoutes(pOratorServiceServer)
+	{
+		require('./MigrationManager-Command-Schemas.js')(this, pOratorServiceServer);
+		require('./MigrationManager-Command-Connections.js')(this, pOratorServiceServer);
+		require('./MigrationManager-Command-DiffMigrate.js')(this, pOratorServiceServer);
+
+		this.fable.log.info('Retold Data Service MigrationManager API routes registered.');
+	}
+
+	/**
+	 * Register the web UI and static library routes on the Orator service server.
+	 *
+	 * @param {Object} pOratorServiceServer - The Orator ServiceServer instance
+	 */
+	connectWebUIRoutes(pOratorServiceServer)
+	{
+		require('./MigrationManager-Command-WebUI.js')(this, pOratorServiceServer);
+
+		this.fable.log.info('Retold Data Service MigrationManager Web UI routes registered.');
+	}
+}
+
+module.exports = RetoldDataServiceMigrationManager;
+module.exports.serviceType = 'RetoldDataServiceMigrationManager';
+module.exports.default_configuration = {};

package/source/services/stricture/Retold-Data-Service-Stricture.js

@@ -0,0 +1,303 @@
+/**
+ * Retold Data Service - Stricture Service
+ *
+ * Fable service that exposes stricture compilation and generation
+ * capabilities via REST endpoints under /1.0/Retold/Stricture/.
+ *
+ * Stricture is a procedural CLI tool (not a service provider), so this
+ * service calls its internal compiler and generator functions directly,
+ * creating fresh Fable contexts for each operation to avoid state leakage.
+ *
+ * @author Steven Velozo <steven@velozo.com>
+ */
+const libFableServiceProviderBase = require('fable-serviceproviderbase');
+
+const libFable = require('fable');
+const libFS = require('fs');
+const libPath = require('path');
+const libOS = require('os');
+
+// Require stricture internals directly — these are plain functions, not service providers
+const libStrictureCompile = require('stricture/source/Stricture-Compile.js');
+const libStricturePrepare = require('stricture/source/Stricture-Run-Prepare.js');
+
+class RetoldDataServiceStricture extends libFableServiceProviderBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'RetoldDataServiceStricture';
+	}
+
+	/**
+	 * Create a fresh Fable instance configured for a stricture operation.
+	 *
+	 * Each operation gets its own isolated context to avoid state leakage
+	 * between concurrent requests.
+	 *
+	 * @param {Object} pSettings - Settings to merge into the Fable instance
+	 * @return {Object} A Fable instance ready for stricture operations
+	 */
+	_createStrictureContext(pSettings)
+	{
+		let tmpSettings = Object.assign(
+			{
+				Product: 'RetoldDataServiceStricture',
+				LogStreams: [{ streamtype: 'console', level: 'fatal' }]
+			}, pSettings);
+
+		let tmpFable = libFable.new(tmpSettings);
+
+		// Set up stricture extensions (LoadJSON, GenerateIndexedTables)
+		libStricturePrepare(tmpFable, () => {});
+
+		return tmpFable;
+	}
+
+	/**
+	 * Create a temporary directory for stricture I/O.
+	 *
+	 * @return {string} Absolute path to the temp directory
+	 */
+	createTempDir()
+	{
+		return libFS.mkdtempSync(libPath.join(libOS.tmpdir(), 'retold-stricture-'));
+	}
+
+	/**
+	 * Recursively remove a temporary directory and all its contents.
+	 *
+	 * @param {string} pDir - Absolute path to the temp directory
+	 */
+	cleanupTempDir(pDir)
+	{
+		try
+		{
+			libFS.rmSync(pDir, { recursive: true, force: true });
+		}
+		catch (pError)
+		{
+			this.fable.log.warn(`Failed to clean up temp directory [${pDir}]: ${pError}`);
+		}
+	}
+
+	/**
+	 * Read all files from a directory and return them as a map of filename → content.
+	 *
+	 * @param {string} pDir - Directory to read
+	 * @return {Object} Map of filename → file content (string)
+	 */
+	readAllFiles(pDir)
+	{
+		let tmpFiles = {};
+		let tmpEntries = libFS.readdirSync(pDir, { withFileTypes: true });
+
+		for (let i = 0; i < tmpEntries.length; i++)
+		{
+			if (tmpEntries[i].isFile())
+			{
+				tmpFiles[tmpEntries[i].name] = libFS.readFileSync(libPath.join(pDir, tmpEntries[i].name), 'utf8');
+			}
+		}
+
+		return tmpFiles;
+	}
+
+	/**
+	 * Compile DDL content to a stricture model.
+	 *
+	 * Accepts either:
+	 *   - { DDL: "string content" } for a single DDL file
+	 *   - { Files: { "name.ddl": "content", ... }, EntryPoint: "name.ddl" } for multi-file
+	 *
+	 * @param {Object} pInput - The DDL input
+	 * @param {function} fCallback - Callback as fCallback(pError, pCompiledModel)
+	 */
+	compileFromDDL(pInput, fCallback)
+	{
+		let tmpInputDir = this.createTempDir();
+		let tmpOutputDir = this.createTempDir();
+
+		let tmpEntryPoint;
+
+		try
+		{
+			if (pInput.DDL && typeof(pInput.DDL) === 'string')
+			{
+				// Single DDL string shorthand
+				tmpEntryPoint = 'Model.ddl';
+				libFS.writeFileSync(libPath.join(tmpInputDir, tmpEntryPoint), pInput.DDL, 'utf8');
+			}
+			else if (pInput.Files && typeof(pInput.Files) === 'object')
+			{
+				// Multi-file virtual filesystem
+				let tmpFileNames = Object.keys(pInput.Files);
+				for (let i = 0; i < tmpFileNames.length; i++)
+				{
+					let tmpFilePath = libPath.join(tmpInputDir, tmpFileNames[i]);
+					// Create subdirectories for paths like "entities/Author.ddl"
+					let tmpFileDir = libPath.dirname(tmpFilePath);
+					if (!libFS.existsSync(tmpFileDir))
+					{
+						libFS.mkdirSync(tmpFileDir, { recursive: true });
+					}
+					libFS.writeFileSync(tmpFilePath, pInput.Files[tmpFileNames[i]], 'utf8');
+				}
+				tmpEntryPoint = pInput.EntryPoint || tmpFileNames[0];
+			}
+			else
+			{
+				this.cleanupTempDir(tmpInputDir);
+				this.cleanupTempDir(tmpOutputDir);
+				return fCallback(new Error('Request body must include DDL (string) or Files (object).'));
+			}
+
+			let tmpEntryPointPath = libPath.join(tmpInputDir, tmpEntryPoint);
+
+			// Create a fresh stricture context for this compilation
+			let tmpStrictureContext = this._createStrictureContext(
+				{
+					InputFileName: tmpEntryPointPath,
+					OutputLocation: tmpOutputDir + '/',
+					OutputFileName: 'Model'
+				});
+
+			// Call the compiler directly — it reads DDL from InputFileName,
+			// writes JSON to OutputLocation, and stores the model in tmpStrictureContext.Stricture
+			libStrictureCompile(tmpStrictureContext,
+				(pError) =>
+				{
+					let tmpResult = null;
+
+					if (!pError)
+					{
+						// The compiler stores the compiled model in the fable context's Stricture property
+						tmpResult = tmpStrictureContext.Stricture;
+					}
+
+					this.cleanupTempDir(tmpInputDir);
+					this.cleanupTempDir(tmpOutputDir);
+					return fCallback(pError, tmpResult);
+				});
+		}
+		catch (pError)
+		{
+			this.cleanupTempDir(tmpInputDir);
+			this.cleanupTempDir(tmpOutputDir);
+			return fCallback(pError);
+		}
+	}
+
+	/**
+	 * Run a stricture generator function against a model and return the output files.
+	 *
+	 * Creates a fresh Fable context, sets up the model and indices,
+	 * runs the generator, reads the output files, and cleans up.
+	 *
+	 * @param {function} pGeneratorFunction - The stricture generator function (e.g. require('stricture/source/Stricture-Generate-MySQL.js'))
+	 * @param {Object} pModel - The compiled stricture model (Extended JSON format)
+	 * @param {function} fCallback - Callback as fCallback(pError, pFiles)
+	 */
+	generateFromModel(pGeneratorFunction, pModel, fCallback)
+	{
+		if (!pModel || !pModel.Tables)
+		{
+			return fCallback(new Error('Model must include a Tables object.'));
+		}
+
+		let tmpOutputDir = this.createTempDir();
+
+		try
+		{
+			// Create a fresh context with output settings
+			let tmpStrictureContext = this._createStrictureContext(
+				{
+					InputFileName: 'unused',
+					OutputLocation: tmpOutputDir + '/',
+					OutputFileName: 'Model'
+				});
+
+			// Set up the model data that generators read from
+			tmpStrictureContext.Model = pModel;
+			tmpStrictureContext.ModelIndices = tmpStrictureContext.StrictureExtensions.GenerateIndexedTables(pModel);
+			tmpStrictureContext.settings.ExtendedModel = pModel.hasOwnProperty('Authorization');
+
+			// Generators are synchronous — they write files directly to OutputLocation
+			pGeneratorFunction(tmpStrictureContext);
+
+			let tmpFiles = this.readAllFiles(tmpOutputDir);
+			this.cleanupTempDir(tmpOutputDir);
+			return fCallback(null, tmpFiles);
+		}
+		catch (pError)
+		{
+			this.cleanupTempDir(tmpOutputDir);
+			return fCallback(pError);
+		}
+	}
+
+	/**
+	 * Helper to register a generator endpoint route.
+	 *
+	 * Creates a POST endpoint at /1.0/Retold/Stricture/Generate/{pRouteSuffix}
+	 * that accepts a model in the body and returns generated files.
+	 *
+	 * @param {Object} pOratorServiceServer - The Orator ServiceServer instance
+	 * @param {string} pRouteSuffix - Route suffix (e.g. 'MySQL', 'Meadow')
+	 * @param {function} pGeneratorFunction - The stricture generator function
+	 */
+	registerGenerateEndpoint(pOratorServiceServer, pRouteSuffix, pGeneratorFunction)
+	{
+		let tmpSelf = this;
+
+		pOratorServiceServer.postWithBodyParser(`/1.0/Retold/Stricture/Generate/${pRouteSuffix}`,
+			(pRequest, pResponse, fNext) =>
+			{
+				if (!pRequest.body || !pRequest.body.Model)
+				{
+					pResponse.send(400, { Error: 'Request body must include Model.' });
+					return fNext();
+				}
+
+				tmpSelf.generateFromModel(pGeneratorFunction, pRequest.body.Model,
+					(pError, pFiles) =>
+					{
+						if (pError)
+						{
+							pResponse.send(500, { Error: pError.message });
+							return fNext();
+						}
+						pResponse.send(200, { Files: pFiles });
+						return fNext();
+					});
+			});
+	}
+
+	/**
+	 * Register all stricture REST routes on the Orator service server.
+	 *
+	 * @param {Object} pOratorServiceServer - The Orator ServiceServer instance
+	 */
+	connectRoutes(pOratorServiceServer)
+	{
+		// Load and register each command module
+		require('./Stricture-Command-Compile.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-MySQL.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-MySQLMigrate.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-Meadow.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-Markdown.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-LaTeX.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-DictionaryCSV.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-ModelGraph.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-AuthorizationChart.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-Pict.js')(this, pOratorServiceServer);
+		require('./Stricture-Command-Generate-TestObjectContainers.js')(this, pOratorServiceServer);
+
+		this.fable.log.info('Retold Data Service Stricture routes registered.');
+	}
+}
+
+module.exports = RetoldDataServiceStricture;
+module.exports.serviceType = 'RetoldDataServiceStricture';
+module.exports.default_configuration = {};

package/source/services/stricture/Stricture-Command-Compile.js

@@ -0,0 +1,39 @@
+/**
+ * Stricture Command - Compile DDL
+ *
+ * POST /1.0/Retold/Stricture/Compile
+ *
+ * Accepts MicroDDL content and returns the compiled stricture model
+ * (MeadowModel-Extended.json format).
+ *
+ * Body formats:
+ *   Single file:  { "DDL": "!Book\n@IDBook\n..." }
+ *   Multi-file:   { "Files": { "Main.ddl": "...", "entities/Author.ddl": "..." }, "EntryPoint": "Main.ddl" }
+ *
+ * @param {Object} pStrictureService - The RetoldDataServiceStricture instance
+ * @param {Object} pOratorServiceServer - The Orator ServiceServer instance
+ */
+module.exports = function(pStrictureService, pOratorServiceServer)
+{
+	pOratorServiceServer.postWithBodyParser('/1.0/Retold/Stricture/Compile',
+		(pRequest, pResponse, fNext) =>
+		{
+			if (!pRequest.body)
+			{
+				pResponse.send(400, { Error: 'Request body must include DDL (string) or Files (object).' });
+				return fNext();
+			}
+
+			pStrictureService.compileFromDDL(pRequest.body,
+				(pError, pCompiledModel) =>
+				{
+					if (pError)
+					{
+						pResponse.send(500, { Error: pError.message });
+						return fNext();
+					}
+					pResponse.send(200, pCompiledModel);
+					return fNext();
+				});
+		});
+};

package/source/services/stricture/Stricture-Command-Generate-AuthorizationChart.js

@@ -0,0 +1,14 @@
+/**
+ * Stricture Command - Generate Authorization Chart
+ *
+ * POST /1.0/Retold/Stricture/Generate/AuthorizationChart
+ *
+ * Accepts a compiled stricture model and returns an authorization chart document.
+ *
+ * Body: { "Model": { "Tables": { ... }, "Authorization": { ... }, ... } }
+ * Returns: { "Files": { ... } }
+ */
+module.exports = function(pStrictureService, pOratorServiceServer)
+{
+	pStrictureService.registerGenerateEndpoint(pOratorServiceServer, 'AuthorizationChart', require('stricture/source/Stricture-Generate-Authorization-Chart.js'));
+};