@anu8151/adonisjs-blueprint 0.2.0

package/build/src/commands/build.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export declare class BuildBlueprint extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    draftFile: string;
+    erase: boolean;
+    watch: boolean;
+    force: boolean;
+    private manifest;
+    run(): Promise<void>;
+    private eraseExisting;
+    private build;
+}
+export default BuildBlueprint;

package/build/src/commands/build.js

@@ -0,0 +1,177 @@
+import { t as BlueprintParser } from "../../parser-DJB5DEck.js";
+import { ModelGenerator } from "../generators/model_generator.js";
+import { MigrationGenerator } from "../generators/migration_generator.js";
+import { ControllerGenerator } from "../generators/controller_generator.js";
+import { ValidatorGenerator } from "../generators/validator_generator.js";
+import { FactoryGenerator } from "../generators/factory_generator.js";
+import { RouteGenerator } from "../generators/route_generator.js";
+import { TestGenerator } from "../generators/test_generator.js";
+import { ViewGenerator } from "../generators/view_generator.js";
+import { SeederGenerator } from "../generators/seeder_generator.js";
+import { PolicyGenerator } from "../generators/policy_generator.js";
+import { EnumGenerator } from "../generators/enum_generator.js";
+import { MiddlewareGenerator } from "../generators/middleware_generator.js";
+import { OpenAPIGenerator } from "../generators/openapi_generator.js";
+import { ChannelGenerator } from "../generators/channel_generator.js";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { BaseCommand, args, flags } from "@adonisjs/core/ace";
+import string from "@adonisjs/core/helpers/string";
+//#region \0@oxc-project+runtime@0.122.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/commands/build.ts
+var BuildBlueprint = class extends BaseCommand {
+	static commandName = "blueprint:build";
+	static description = "Build the application from the draft.yaml file";
+	manifest = [];
+	async run() {
+		if (this.watch) {
+			this.logger.info(`Watching for changes in ${this.draftFile}...`);
+			const { watch } = await import("node:fs");
+			await this.build();
+			watch(this.app.makePath(this.draftFile)).on("change", async () => {
+				this.logger.info("Changes detected, rebuilding...");
+				await this.build();
+			});
+			return;
+		}
+		await this.build();
+	}
+	async eraseExisting() {
+		const manifestPath = this.app.makePath(".blueprint_manifest.json");
+		if (existsSync(manifestPath)) {
+			this.logger.info("Erasing existing generated files...");
+			const files = JSON.parse(readFileSync(manifestPath, "utf8")).files || [];
+			for (const file of files) if (existsSync(file)) {
+				unlinkSync(file);
+				this.logger.action(`deleted ${file}`).succeeded();
+			}
+			unlinkSync(manifestPath);
+		}
+	}
+	async build() {
+		if (this.erase) await this.eraseExisting();
+		this.logger.info("Building application from " + this.draftFile);
+		const blueprint = await new BlueprintParser().parse(this.draftFile);
+		this.manifest = [];
+		if (blueprint.auth) {
+			this.logger.info("Auth shorthand detected. Injecting AuthController...");
+			if (!blueprint.controllers) blueprint.controllers = {};
+			if (!blueprint.controllers["Auth"]) blueprint.controllers["Auth"] = {
+				login: { render: "auth/login" },
+				register: { render: "auth/register" },
+				store: {
+					validate: "email, password",
+					auth: "true",
+					redirect: "dashboard"
+				},
+				logout: {
+					auth: "logout",
+					redirect: "login"
+				}
+			};
+			if (!blueprint.models) blueprint.models = {};
+			if (!blueprint.models["User"]) blueprint.models["User"] = { attributes: {
+				email: "string:unique",
+				password: "string",
+				full_name: "string:optional"
+			} };
+		}
+		const forceOverwrite = this.force || this.erase;
+		if (blueprint.models) {
+			const modelGenerator = new ModelGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const migrationGenerator = new MigrationGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const validatorGenerator = new ValidatorGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const factoryGenerator = new FactoryGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const seederGenerator = new SeederGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const enumGenerator = new EnumGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			for (const [name, definition] of Object.entries(blueprint.models)) {
+				this.logger.info(`Generating model, migration, validator, factory and seeder for ${name}`);
+				await modelGenerator.generate(name, definition);
+				await migrationGenerator.generate(name, definition);
+				await validatorGenerator.generate(name, definition);
+				await factoryGenerator.generate(name, definition);
+				await seederGenerator.generate(name, definition);
+				if (definition.attributes) {
+					for (const [attrName, attrType] of Object.entries(definition.attributes)) if (typeof attrType === "string" && attrType.startsWith("enum:")) {
+						const enumName = string.pascalCase(name + "_" + attrName);
+						const values = attrType.split(":")[1].split(",").map((v) => v.trim());
+						this.logger.info(`Generating enum ${enumName}`);
+						await enumGenerator.generate(enumName, { values });
+					}
+				}
+			}
+		}
+		if (blueprint.controllers) {
+			const controllerGenerator = new ControllerGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const routeGenerator = new RouteGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const testGenerator = new TestGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const viewGenerator = new ViewGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const policyGenerator = new PolicyGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const middlewareGenerator = new MiddlewareGenerator(this.app, this.logger, this.manifest, void 0, forceOverwrite);
+			const useInertia = blueprint.settings?.inertia?.enabled || false;
+			const adapter = blueprint.settings?.inertia?.adapter || "react";
+			const isApi = blueprint.settings?.api || false;
+			for (const [name, definition] of Object.entries(blueprint.controllers)) {
+				this.logger.info(`Generating controller, routes, tests and policies for ${name}`);
+				await controllerGenerator.generate(name, definition, useInertia, isApi, blueprint.models);
+				await routeGenerator.generate(name, definition, isApi);
+				await testGenerator.generate(name, definition, blueprint);
+				await policyGenerator.generate(name, definition);
+				if (definition.middleware) {
+					for (const mw of definition.middleware) if (![
+						"auth",
+						"guest",
+						"silentAuth"
+					].includes(mw)) {
+						this.logger.info(`Generating middleware ${mw}`);
+						await middlewareGenerator.generate(mw);
+					}
+				}
+				if (!isApi) {
+					for (const actionDef of Object.values(definition)) if (typeof actionDef === "object" && actionDef !== null && actionDef.render) {
+						const viewPath = actionDef.render;
+						this.logger.info(`Generating view ${viewPath} (${useInertia ? adapter : "edge"})`);
+						const modelName = string.pascalCase(string.singular(name));
+						const modelDef = blueprint.models ? blueprint.models[modelName] : null;
+						await viewGenerator.generate(viewPath, useInertia, adapter, modelDef);
+					}
+				}
+			}
+		}
+		if (blueprint.channels) await new ChannelGenerator(this.app, this.logger, this.manifest).generate("", blueprint.channels);
+		if (blueprint.settings?.api) {
+			this.logger.info("Generating API documentation...");
+			await new OpenAPIGenerator(this.app, this.logger, this.manifest).generate("", blueprint);
+		}
+		if (this.manifest.length > 0) {
+			const manifestPath = this.app.makePath(".blueprint_manifest.json");
+			writeFileSync(manifestPath, JSON.stringify({ files: this.manifest }, null, 2));
+			this.logger.info(`Manifest saved to ${manifestPath}`);
+		}
+		this.logger.success("Application built successfully");
+	}
+};
+__decorate([args.string({
+	description: "The draft file to build from",
+	default: "draft.yaml"
+})], BuildBlueprint.prototype, "draftFile", void 0);
+__decorate([flags.boolean({
+	alias: "e",
+	description: "Erase existing files before building"
+})], BuildBlueprint.prototype, "erase", void 0);
+__decorate([flags.boolean({
+	alias: "w",
+	description: "Watch the draft file for changes"
+})], BuildBlueprint.prototype, "watch", void 0);
+__decorate([flags.boolean({
+	alias: "f",
+	description: "Force overwrite existing files"
+})], BuildBlueprint.prototype, "force", void 0);
+//#endregion
+export { BuildBlueprint, BuildBlueprint as default };

package/build/src/commands/erase.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class EraseBlueprint extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/build/src/commands/erase.js

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { BaseCommand } from "@adonisjs/core/ace";
+//#region src/commands/erase.ts
+var EraseBlueprint = class extends BaseCommand {
+	static commandName = "blueprint:erase";
+	static description = "Erase the files generated by the last blueprint:build";
+	async run() {
+		const manifestPath = this.app.makePath(".blueprint_manifest.json");
+		if (!existsSync(manifestPath)) {
+			this.logger.error("Manifest file not found. Nothing to erase.");
+			return;
+		}
+		const files = JSON.parse(readFileSync(manifestPath, "utf8")).files || [];
+		for (const file of files) if (existsSync(file)) {
+			unlinkSync(file);
+			this.logger.action(`deleted ${file}`).succeeded();
+		}
+		unlinkSync(manifestPath);
+		this.logger.success("Erased generated files successfully");
+	}
+};
+//#endregion
+export { EraseBlueprint as default };

package/build/src/commands/init.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class InitBlueprint extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/build/src/commands/main.d.ts

@@ -0,0 +1 @@
+export declare const commands: (() => Promise<typeof import("./erase.js")>)[];

package/build/src/commands/main.js

@@ -0,0 +1,10 @@
+//#region src/commands/main.ts
+const commands = [
+	() => import("./build.js"),
+	() => import("./erase.js"),
+	() => import("./trace.js"),
+	() => import("./stubs.js"),
+	() => import("../../init-TjAcOVVP.js")
+];
+//#endregion
+export { commands };

package/build/src/commands/stubs.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class EjectStubs extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/build/src/commands/stubs.js

@@ -0,0 +1,16 @@
+import { t as stubsRoot } from "../../main-1fZp_M_R.js";
+import { BaseCommand } from "@adonisjs/core/ace";
+//#region src/commands/stubs.ts
+var EjectStubs = class extends BaseCommand {
+	static commandName = "blueprint:stubs";
+	static description = "Publish blueprint stubs to your project root";
+	async run() {
+		await (await this.app.stubs.create()).copy(stubsRoot, {
+			overwrite: false,
+			source: stubsRoot
+		});
+		this.logger.success("Stubs published to ./stubs/blueprint");
+	}
+};
+//#endregion
+export { EjectStubs as default };

package/build/src/commands/trace.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class TraceBlueprint extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/build/src/commands/trace.js

@@ -0,0 +1,60 @@
+import { writeFileSync } from "node:fs";
+import { stringify } from "yaml";
+import { BaseCommand } from "@adonisjs/core/ace";
+import string from "@adonisjs/core/helpers/string";
+//#region src/commands/trace.ts
+var TraceBlueprint = class extends BaseCommand {
+	static commandName = "blueprint:trace";
+	static description = "Trace the database and generate a draft.yaml file";
+	async run() {
+		this.logger.info("Tracing database to generate draft.yaml...");
+		try {
+			const connection = (await import("@adonisjs/lucid/services/db")).default.connection();
+			const tables = await connection.inspect();
+			const draft = { models: {} };
+			for (const table of tables) {
+				if ([
+					"adonis_schema",
+					"adonis_schema_versions",
+					"lucid_models"
+				].includes(table.name)) continue;
+				const modelName = string.pascalCase(string.singular(table.name));
+				draft.models[modelName] = {
+					attributes: {},
+					relationships: {}
+				};
+				const columns = await connection.getColumns(table.name);
+				for (const column of columns) {
+					if ([
+						"id",
+						"created_at",
+						"updated_at",
+						"deleted_at"
+					].includes(column.name)) {
+						if (column.name === "deleted_at") draft.models[modelName].softDeletes = true;
+						continue;
+					}
+					if (column.name.endsWith("_id")) {
+						const relName = string.camelCase(column.name.replace("_id", ""));
+						draft.models[modelName].relationships[relName] = "belongsTo";
+						continue;
+					}
+					let type = "string";
+					if (column.type === "integer" || column.type === "int") type = "integer";
+					if (column.type === "boolean" || column.type === "tinyint") type = "boolean";
+					if (column.type === "timestamp" || column.type === "datetime") type = "timestamp";
+					draft.models[modelName].attributes[column.name] = type;
+				}
+				if (Object.keys(draft.models[modelName].attributes).length === 0) delete draft.models[modelName].attributes;
+				if (Object.keys(draft.models[modelName].relationships).length === 0) delete draft.models[modelName].relationships;
+			}
+			writeFileSync(this.app.makePath("draft.yaml"), stringify(draft));
+			this.logger.success("draft.yaml generated successfully from database");
+		} catch (error) {
+			this.logger.error("Failed to trace database. Make sure Lucid is configured.");
+			this.logger.debug(error);
+		}
+	}
+};
+//#endregion
+export { TraceBlueprint as default };

package/build/src/generators/base_generator.d.ts

@@ -0,0 +1,12 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+import { Codemods } from '@adonisjs/core/ace/codemods';
+export declare abstract class BaseGenerator {
+    protected app: ApplicationService;
+    protected logger: any;
+    protected manifest?: string[] | undefined;
+    protected forceOverwrite: boolean;
+    protected codemods: Codemods;
+    constructor(app: ApplicationService, logger: any, manifest?: string[] | undefined, codemods?: Codemods, forceOverwrite?: boolean);
+    protected generateStub(stubPath: string, stubState: any, customStubPath?: string): Promise<import("@adonisjs/application/types").GeneratedStub>;
+    abstract generate(name: string, definition: any, ...args: any[]): Promise<void>;
+}

package/build/src/generators/base_generator.js

@@ -0,0 +1,31 @@
+import { t as stubsRoot } from "../../main-1fZp_M_R.js";
+import { basename, dirname, isAbsolute } from "node:path";
+import { Codemods } from "@adonisjs/core/ace/codemods";
+//#region src/generators/base_generator.ts
+var BaseGenerator = class {
+	codemods;
+	constructor(app, logger, manifest, codemods, forceOverwrite = false) {
+		this.app = app;
+		this.logger = logger;
+		this.manifest = manifest;
+		this.forceOverwrite = forceOverwrite;
+		this.codemods = codemods || new Codemods(this.app, this.logger);
+	}
+	async generateStub(stubPath, stubState, customStubPath) {
+		let finalStubRoot = stubsRoot;
+		let finalStubPath = stubPath;
+		if (customStubPath) if (isAbsolute(customStubPath)) {
+			finalStubRoot = dirname(customStubPath);
+			finalStubPath = basename(customStubPath);
+		} else {
+			finalStubRoot = this.app.appRoot.toString();
+			finalStubPath = customStubPath;
+		}
+		this.codemods.overwriteExisting = this.forceOverwrite;
+		const result = await this.codemods.makeUsingStub(finalStubRoot, finalStubPath, stubState);
+		if (this.manifest && result && result.destination) this.manifest.push(result.destination);
+		return result;
+	}
+};
+//#endregion
+export { BaseGenerator };

package/build/src/generators/channel_generator.d.ts

@@ -0,0 +1,4 @@
+import { BaseGenerator } from './base_generator.js';
+export declare class ChannelGenerator extends BaseGenerator {
+    generate(_name: string, channels: Record<string, any>): Promise<void>;
+}

package/build/src/generators/channel_generator.js

@@ -0,0 +1,25 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/channel_generator.ts
+var ChannelGenerator = class extends BaseGenerator {
+	async generate(_name, channels) {
+		const outputPath = this.app.makePath("start/transmission.ts");
+		let content = "import transmission from '@adonisjs/transmission/services/main'\n\n";
+		for (const [name, definition] of Object.entries(channels)) {
+			const channelName = definition.name || name.toLowerCase();
+			content += `transmission.authorize('${channelName}', async (user) => {\n`;
+			if (definition.authorized) content += `  return !!user\n`;
+			else content += `  return true\n`;
+			content += `})\n\n`;
+		}
+		const { writeFileSync } = await import("node:fs");
+		const { existsSync, mkdirSync } = await import("node:fs");
+		const { dirname } = await import("node:path");
+		const dir = dirname(outputPath);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileSync(outputPath, content);
+		this.logger.action(`create ${outputPath}`).succeeded();
+		if (this.manifest) this.manifest.push(outputPath);
+	}
+};
+//#endregion
+export { ChannelGenerator };

package/build/src/generators/class_generator.d.ts

@@ -0,0 +1,4 @@
+import { BaseGenerator } from './base_generator.js';
+export declare class ClassGenerator extends BaseGenerator {
+    generate(name: string, type: 'event' | 'mail' | 'job'): Promise<void>;
+}

package/build/src/generators/class_generator.js

@@ -0,0 +1,11 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/class_generator.ts
+var ClassGenerator = class extends BaseGenerator {
+	async generate(name, type) {
+		const entity = this.app.generators.createEntity(name);
+		const stubPath = `make/${type}/main.stub`;
+		await this.generateStub(stubPath, { entity });
+	}
+};
+//#endregion
+export { ClassGenerator };

package/build/src/generators/controller_generator.d.ts

@@ -0,0 +1,5 @@
+import { BaseGenerator } from './base_generator.js';
+import '../statements/index.js';
+export declare class ControllerGenerator extends BaseGenerator {
+    generate(name: string, definition: any, useInertia?: boolean, isApi?: boolean, models?: any): Promise<void>;
+}