@researchdatabox/redbox-dev-tools 0.0.1-beta.8936

package/dist/generators/form-field.d.ts

@@ -0,0 +1,15 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+export interface FormFieldGeneratorOptions extends GeneratorOptions {
+    name: string;
+    type: string;
+}
+export declare class FormFieldGenerator extends Generator {
+    private name;
+    private type;
+    constructor(options: FormFieldGeneratorOptions);
+    generate(): Promise<void>;
+    private escapeJsString;
+    private escapeForComment;
+    private generateFormContent;
+    private getSafeFileName;
+}

package/dist/generators/form-field.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormFieldGenerator = void 0;
+const path = __importStar(require("path"));
+const generator_1 = require("../utils/generator");
+class FormFieldGenerator extends generator_1.Generator {
+    name;
+    type;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.type = options.type;
+    }
+    async generate() {
+        const safeName = this.getSafeFileName(this.name);
+        const fileName = safeName.endsWith('.js') ? safeName : `${safeName}.js`;
+        const formConfigDir = path.join(this.root, 'form-config');
+        const filePath = path.resolve(formConfigDir, fileName);
+        if (!filePath.startsWith(path.resolve(formConfigDir) + path.sep)) {
+            throw new Error(`Form field path resolves outside form-config: ${fileName}`);
+        }
+        const content = this.generateFormContent();
+        await this.writeFile(filePath, content);
+    }
+    escapeJsString(value) {
+        return value
+            .replace(/\\/g, '\\\\')
+            .replace(/'/g, "\\'")
+            .replace(/\r/g, '\\r')
+            .replace(/\n/g, '\\n')
+            .replace(/\t/g, '\\t')
+            .replace(/\u2028/g, '\\u2028')
+            .replace(/\u2029/g, '\\u2029');
+    }
+    escapeForComment(value) {
+        return value
+            .replace(/\*\//g, '*\\/')
+            .replace(/\/\*/g, '/\\*');
+    }
+    generateFormContent() {
+        const escapedName = this.escapeJsString(this.name);
+        const commentName = this.escapeForComment(escapedName);
+        const escapedType = this.escapeJsString(this.type);
+        return `/**
+   * ${commentName} form configuration
+ */
+module.exports = {
+  name: '${escapedName}',
+  type: '${escapedType}',
+  skipValidationOnSave: false,
+  editCssClasses: 'row col-md-12',
+  viewCssClasses: 'row col-md-offset-1 col-md-10',
+  messages: {
+    "saving": ["@dmpt-form-saving"],
+    "validationFail": ["@dmpt-form-validation-fail-prefix", "@dmpt-form-validation-fail-suffix"],
+    "saveSuccess": ["@dmpt-form-save-success"],
+    "saveError": ["@dmpt-form-save-error"]
+  },
+  fields: [
+    {
+      class: 'Container',
+      compClass: 'TextBlockComponent',
+      viewOnly: true,
+      definition: {
+        name: 'titleBlock',
+        type: 'h1',
+        value: '\${title}'
+      }
+    },
+    {
+      class: 'TextField',
+      definition: {
+        name: 'title',
+        label: 'Title',
+        type: 'text',
+        required: true
+      }
+    },
+    {
+      class: 'TextArea',
+      definition: {
+        name: 'description',
+        label: 'Description',
+        type: 'text'
+      }
+    },
+    {
+      class: "ButtonBarContainer",
+      compClass: "ButtonBarContainerComponent",
+      definition: {
+        fields: [
+          {
+            class: "SaveButton",
+            definition: {
+              label: '@save-button',
+              cssClasses: 'btn-success'
+            }
+          },
+          {
+            class: "CancelButton",
+            definition: {
+              label: '@close-button',
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+`;
+    }
+    getSafeFileName(name) {
+        const trimmed = name.trim();
+        if (!trimmed) {
+            throw new Error('Form field name cannot be empty.');
+        }
+        const baseName = path.basename(trimmed);
+        if (baseName !== trimmed) {
+            throw new Error(`Form field name contains path separators: ${name}`);
+        }
+        if (!/^[A-Za-z0-9._-]+$/.test(baseName)) {
+            throw new Error(`Form field name contains invalid characters: ${name}`);
+        }
+        return baseName;
+    }
+}
+exports.FormFieldGenerator = FormFieldGenerator;

package/dist/generators/model.d.ts

@@ -0,0 +1,42 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+export interface ModelAttribute {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'json' | 'ref';
+    required?: boolean;
+    unique?: boolean;
+    columnType?: string;
+    defaultsTo?: string | number | boolean | Record<string, unknown> | unknown[] | null;
+}
+export interface ModelAssociation {
+    name: string;
+    type: 'belongsTo' | 'hasMany';
+    model: string;
+    via?: string;
+    dominant?: boolean;
+}
+export interface ModelGeneratorOptions extends GeneratorOptions {
+    name: string;
+    attributes?: ModelAttribute[];
+    associations?: ModelAssociation[];
+    identity?: string;
+    paths: RedboxPaths;
+}
+export declare class ModelGenerator extends Generator {
+    private name;
+    private attributes;
+    private associations;
+    private identity;
+    private paths;
+    private project;
+    constructor(options: ModelGeneratorOptions);
+    generate(): Promise<void>;
+    private generateModelContent;
+    private buildImports;
+    private buildDecorators;
+    private buildProperties;
+    private buildAttributeOptions;
+    private formatDefaultValue;
+    private tsType;
+    private buildAttributesInterface;
+}

package/dist/generators/model.js

@@ -0,0 +1,206 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelGenerator = void 0;
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+const generator_1 = require("../utils/generator");
+const config_helper_1 = require("../utils/config-helper");
+class ModelGenerator extends generator_1.Generator {
+    name;
+    attributes;
+    associations;
+    identity;
+    paths;
+    project;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.attributes = options.attributes || [];
+        this.associations = options.associations || [];
+        // Identity is the Waterline table/collection name (lowercase)
+        this.identity = options.identity || options.name.toLowerCase().replace(/class$/i, '');
+        this.paths = options.paths;
+        this.project = new ts_morph_1.Project({
+            manipulationSettings: {
+                quoteKind: ts_morph_1.QuoteKind.Single,
+            },
+        });
+    }
+    async generate() {
+        // Ensure class name ends with 'Class' (convention for Waterline decorator models)
+        const className = this.name.endsWith('Class') ? this.name : `${this.name}Class`;
+        const baseName = className.replace(/Class$/, '');
+        const modelDir = path.join(this.paths.coreTypes, 'src', 'waterline-models');
+        const modelPath = path.join(modelDir, `${baseName}.ts`);
+        const content = this.generateModelContent(baseName, className);
+        this.writeFile(modelPath, content);
+        if (!this.dryRun) {
+            await (0, config_helper_1.updateModelIndex)({
+                project: this.project,
+                paths: this.paths,
+                root: this.root,
+                modelName: baseName,
+                dryRun: this.dryRun
+            });
+        }
+    }
+    generateModelContent(baseName, className) {
+        const imports = this.buildImports();
+        const decorators = this.buildDecorators();
+        const properties = this.buildProperties();
+        const wlDefExport = `${baseName}WLDef`;
+        const attributesInterface = `${baseName}Attributes`;
+        const waterlineModelInterface = `${baseName}WaterlineModel`;
+        return `/// <reference path="../sails.ts" />
+import { JsonMap } from './types';
+${imports}
+
+@Entity('${this.identity}')
+export class ${className} {
+${decorators}${properties}}
+
+// Export the Waterline model definition for runtime use
+export const ${wlDefExport} = toWaterlineModelDef(${className});
+
+// Type interface for backwards compatibility
+export interface ${attributesInterface} extends Sails.WaterlineAttributes {
+${this.buildAttributesInterface()}}
+
+export interface ${waterlineModelInterface} extends Sails.Model<${attributesInterface}> {
+  attributes: ${attributesInterface};
+}
+
+declare global {
+  var ${baseName}: ${waterlineModelInterface};
+}
+`;
+    }
+    buildImports() {
+        const decoratorImports = ['Entity', 'Attr', 'toWaterlineModelDef'];
+        const hasBelongsTo = this.associations.some(a => a.type === 'belongsTo');
+        const hasHasMany = this.associations.some(a => a.type === 'hasMany');
+        if (hasBelongsTo)
+            decoratorImports.push('BelongsTo');
+        if (hasHasMany)
+            decoratorImports.push('HasMany');
+        return `import { ${decoratorImports.join(', ')} } from '../decorators';`;
+    }
+    buildDecorators() {
+        const lines = [];
+        // Build attribute decorators
+        for (const attr of this.attributes) {
+            const opts = this.buildAttributeOptions(attr);
+            lines.push(`  @Attr(${opts})`);
+            lines.push(`  public ${attr.name}${attr.required ? '!' : '?'}: ${this.tsType(attr.type)};`);
+            lines.push('');
+        }
+        // Build association decorators
+        for (const assoc of this.associations) {
+            if (assoc.type === 'belongsTo') {
+                lines.push(`  @BelongsTo('${assoc.model}')`);
+                lines.push(`  public ${assoc.name}?: string | number;`);
+            }
+            else if (assoc.type === 'hasMany') {
+                if (!assoc.via) {
+                    throw new Error(`Missing 'via' for hasMany association '${assoc.name}'.`);
+                }
+                const opts = assoc.dominant ? `, { dominant: ${assoc.dominant} }` : '';
+                lines.push(`  @HasMany('${assoc.model}', '${assoc.via}'${opts})`);
+                lines.push(`  public ${assoc.name}?: unknown[];`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    buildProperties() {
+        // For now, decorators include properties; this can be extended later
+        return '';
+    }
+    buildAttributeOptions(attr) {
+        const opts = [];
+        opts.push(`type: '${attr.type === 'ref' ? 'ref' : attr.type}'`);
+        if (attr.required)
+            opts.push('required: true');
+        if (attr.unique)
+            opts.push('unique: true');
+        if (attr.columnType)
+            opts.push(`columnType: '${attr.columnType}'`);
+        if (attr.defaultsTo !== undefined) {
+            const val = this.formatDefaultValue(attr.defaultsTo);
+            opts.push(`defaultsTo: ${val}`);
+        }
+        return `{ ${opts.join(', ')} }`;
+    }
+    formatDefaultValue(value) {
+        if (value === null) {
+            return 'null';
+        }
+        if (typeof value === 'string') {
+            return `'${value}'`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        return JSON.stringify(value);
+    }
+    tsType(waterlineType) {
+        switch (waterlineType) {
+            case 'string': return 'string';
+            case 'number': return 'number';
+            case 'boolean': return 'boolean';
+            case 'json': return 'Record<string, unknown>';
+            case 'ref': return 'unknown';
+            default: return 'unknown';
+        }
+    }
+    buildAttributesInterface() {
+        const lines = [];
+        for (const attr of this.attributes) {
+            const optional = attr.required ? '' : '?';
+            lines.push(`  ${attr.name}${optional}: ${this.tsType(attr.type)};`);
+        }
+        for (const assoc of this.associations) {
+            if (assoc.type === 'belongsTo') {
+                lines.push(`  ${assoc.name}?: string | number;`);
+            }
+            else if (assoc.type === 'hasMany') {
+                lines.push(`  ${assoc.name}?: unknown[];`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+exports.ModelGenerator = ModelGenerator;

package/dist/generators/service.d.ts

@@ -0,0 +1,16 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+export interface ServiceGeneratorOptions extends GeneratorOptions {
+    name: string;
+    methods?: string[];
+    paths: RedboxPaths;
+}
+export declare class ServiceGenerator extends Generator {
+    private name;
+    private methods;
+    private paths;
+    private project;
+    constructor(options: ServiceGeneratorOptions);
+    generate(): Promise<void>;
+    private generateServiceContent;
+}

package/dist/generators/service.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceGenerator = void 0;
+const path = __importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
+const generator_1 = require("../utils/generator");
+const config_helper_1 = require("../utils/config-helper");
+class ServiceGenerator extends generator_1.Generator {
+    name;
+    methods;
+    paths;
+    project;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.methods = options.methods || [];
+        this.paths = options.paths;
+        this.project = new ts_morph_1.Project({
+            manipulationSettings: {
+                quoteKind: ts_morph_1.QuoteKind.Single,
+            },
+        });
+    }
+    async generate() {
+        const serviceName = this.name.endsWith('Service') ? this.name : `${this.name}Service`;
+        const className = this.name.endsWith('Service')
+            ? this.name.replace(/Service$/, '')
+            : this.name;
+        const serviceDir = path.join(this.paths.coreTypes, 'src', 'services');
+        const servicePath = path.join(serviceDir, `${serviceName}.ts`);
+        const content = this.generateServiceContent(className, serviceName);
+        this.writeFile(servicePath, content);
+        if (!this.dryRun) {
+            await (0, config_helper_1.updateServiceIndex)({
+                project: this.project,
+                paths: this.paths,
+                root: this.root,
+                serviceName: serviceName,
+                className: className,
+                dryRun: this.dryRun
+            });
+        }
+    }
+    generateServiceContent(className, serviceName) {
+        const methodsCode = this.methods.map(method => `
+    public async ${method}(..._args: unknown[]): Promise<Record<string, unknown>> {
+      sails.log.verbose(\`\${this.logHeader} ${method} called\`);
+      return { message: 'Method ${method} in ${serviceName}' };
+    }`).join('\n');
+        const exportedMethods = ['init', ...this.methods].map(m => `'${m}'`).join(',\n      ');
+        return `import { Services as services } from '../CoreService';
+
+export namespace Services {
+  export class ${className}Service extends services.Core.Service {
+
+    constructor() {
+      super();
+      this.logHeader = "${serviceName}::";
+    }
+
+    protected override _exportedMethods: string[] = [
+      ${exportedMethods}
+    ];
+
+    public init(): void {
+      // Initialize service here
+    }
+${methodsCode}
+  }
+}
+
+declare global {
+  let ${className}Service: Services.${className}Service;
+}
+`;
+    }
+}
+exports.ServiceGenerator = ServiceGenerator;

package/dist/runtime-resolver.d.ts

@@ -0,0 +1,3 @@
+export declare function getResolutionPaths(): string[];
+export declare function resolveFromRedboxContract(request: string): string;
+export declare function requireFromRedboxContract<T = unknown>(request: string): T;

package/dist/runtime-resolver.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolutionPaths = getResolutionPaths;
+exports.resolveFromRedboxContract = resolveFromRedboxContract;
+exports.requireFromRedboxContract = requireFromRedboxContract;
+const path_1 = __importDefault(require("path"));
+function getResolutionPaths() {
+    const paths = [];
+    try {
+        const redboxCorePackageJson = require.resolve('@researchdatabox/redbox-core/package.json');
+        paths.push(path_1.default.dirname(redboxCorePackageJson));
+    }
+    catch (_error) {
+    }
+    paths.push(__dirname);
+    paths.push(process.cwd());
+    return paths;
+}
+function resolveFromRedboxContract(request) {
+    return require.resolve(request, { paths: getResolutionPaths() });
+}
+function requireFromRedboxContract(request) {
+    return require(resolveFromRedboxContract(request));
+}

package/dist/templates/hook-archetype.d.ts

@@ -0,0 +1,12 @@
+export interface HookArchetypeOptions {
+    cwd: string;
+    packageName: string;
+    description?: string;
+    force?: boolean;
+    templateName?: string;
+}
+export interface HookArchetypeResult {
+    created: string[];
+    skipped: string[];
+}
+export declare function generateHookArchetype(options: HookArchetypeOptions): HookArchetypeResult;