@anu8151/adonisjs-blueprint 0.2.0

package/build/src/generators/controller_generator.js

@@ -0,0 +1,355 @@
+import { t as statementsRegistry } from "../../statements_registry-DzyxAiKP.js";
+import { BaseGenerator } from "./base_generator.js";
+import { EventGenerator } from "./event_generator.js";
+import { MailGenerator } from "./mail_generator.js";
+import { JobGenerator } from "./job_generator.js";
+import { NotificationGenerator } from "./notification_generator.js";
+import { ServiceGenerator } from "./service_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/statements/index.ts
+statementsRegistry.register("query", (value, { entity, pluralName, singularName }) => {
+	const parts = value.split(",").map((p) => p.trim());
+	const queryPart = parts[0];
+	const preloads = [];
+	for (const part of parts.slice(1)) if (part.startsWith("with:")) {
+		const relations = part.replace("with:", "").split(",").map((r) => r.trim());
+		preloads.push(...relations);
+	} else preloads.push(part);
+	const queryParts = queryPart.split(":");
+	const queryType = queryParts[0];
+	const variableName = queryType === "all" || queryType === "paginate" ? pluralName : singularName;
+	const logicLines = [];
+	const context = [];
+	let queryChain = `${entity.className}.query()`;
+	for (const relation of preloads) if (relation) queryChain += `.preload('${string.camelCase(relation)}')`;
+	if (queryType === "all") logicLines.push(`const ${variableName} = await ${queryChain}`);
+	else if (queryType === "paginate") {
+		const limit = queryParts[1] || "20";
+		logicLines.push(`const ${variableName} = await ${queryChain}.paginate(request.input('page', 1), ${limit})`);
+	} else if (queryType === "find") {
+		logicLines.push(`const ${variableName} = await ${queryChain}.where('id', params.id).firstOrFail()`);
+		context.push("params");
+	}
+	return {
+		logicLines,
+		imports: { models: [entity.className] },
+		context
+	};
+});
+statementsRegistry.register("authorize", (value, { entity }) => {
+	const authParts = value.split(",");
+	const action = authParts[0].trim();
+	const modelArg = authParts[1] ? `, ${authParts[1].trim()}` : "";
+	const policyName = `${entity.className}Policy`;
+	return {
+		logicLines: [`await bouncer.with(${policyName}).authorize('${action}'${modelArg})`],
+		imports: { policies: [policyName] },
+		context: ["bouncer"]
+	};
+});
+statementsRegistry.register("validate", (value, { actionName, entity }) => {
+	const validatorName = actionName === "store" || actionName === "update" ? `${actionName === "store" ? "create" : "update"}${entity.className}Validator` : "validator";
+	let meta = "";
+	if (actionName === "update") meta = ", { meta: { id: params.id } }";
+	if (typeof value === "string" && value !== "all") return {
+		logicLines: [`const payload = await request.validateUsing(${validatorName}.pick(['${value.split(",").map((f) => f.trim()).join("', '")}'])${meta})`],
+		imports: { validators: [validatorName] },
+		context: actionName === "update" ? ["params"] : []
+	};
+	return {
+		logicLines: [`const payload = await request.validateUsing(${validatorName}${meta})`],
+		imports: { validators: [validatorName] },
+		context: actionName === "update" ? ["params"] : []
+	};
+});
+statementsRegistry.register("save", (value, { entity }) => {
+	const logicLines = [];
+	const parts = typeof value === "string" ? value.split(",").map((p) => p.trim()) : [];
+	const relationships = [];
+	for (const part of parts.slice(1)) if (part.startsWith("with:")) {
+		const relations = part.replace("with:", "").split(",").map((r) => r.trim());
+		relationships.push(...relations);
+	} else relationships.push(part);
+	if (relationships.length > 0) {
+		logicLines.push(`const model = await ${entity.className}.create(payload)`);
+		for (const rel of relationships) if (rel) {
+			const singularRel = string.singular(rel);
+			logicLines.push(`await model.related('${string.camelCase(rel)}').sync(payload.${string.snakeCase(singularRel)}_ids)`);
+		}
+	} else logicLines.push(`await ${entity.className}.create(payload)`);
+	return {
+		logicLines,
+		imports: { models: [entity.className] }
+	};
+});
+statementsRegistry.register("delete", (_value, { entity, models }) => {
+	const modelDef = models ? models[entity.className] : null;
+	const isSoftDelete = modelDef && modelDef.softDeletes;
+	return {
+		logicLines: [`const model = await ${entity.className}.findOrFail(params.id)`, `await model.${isSoftDelete ? "delete()" : "delete()"}`],
+		imports: { models: [entity.className] },
+		context: ["params"]
+	};
+});
+statementsRegistry.register("fire", async (value, { generators }) => {
+	const eventName = value;
+	await generators.event.generate(eventName);
+	return {
+		logicLines: [`emitter.emit(new ${eventName}(payload))`],
+		imports: { events: [eventName] },
+		context: ["emitter"]
+	};
+});
+statementsRegistry.register("send", async (value, { generators }) => {
+	const mailName = value;
+	await generators.mail.generate(mailName);
+	return {
+		logicLines: [`await mail.sendLater(new ${mailName}(payload))`],
+		imports: { mails: [mailName] },
+		context: ["mail"]
+	};
+});
+statementsRegistry.register("dispatch", async (value, { generators }) => {
+	const jobName = value;
+	await generators.job.generate(jobName);
+	return {
+		logicLines: [`await new ${jobName}(payload).handle()`],
+		imports: { jobs: [jobName] }
+	};
+});
+statementsRegistry.register("notify", async (value, { generators }) => {
+	const notifyParts = value.split(", ");
+	const target = notifyParts[0].trim();
+	const notificationName = notifyParts[1].trim();
+	await generators.notification.generate(notificationName);
+	return {
+		logicLines: [`await ${target}.notify(new ${notificationName}(payload))`],
+		imports: { notifications: [notificationName] }
+	};
+});
+statementsRegistry.register("upload", (value) => {
+	const parts = value.split(", ");
+	const uploadParts = parts[0].split(" to: ");
+	const field = uploadParts[0].trim();
+	const disk = uploadParts[1] ? `, '${uploadParts[1].trim()}'` : "";
+	let size = "2mb";
+	let extnames = "['jpg', 'png', 'pdf']";
+	for (const part of parts.slice(1)) if (part.startsWith("size:")) size = part.replace("size:", "").trim();
+	else if (part.startsWith("ext:")) extnames = `['${part.replace("ext:", "").trim().split(",").join("', '")}']`;
+	return { logicLines: [`const ${field}File = request.file('${field}', { size: '${size}', extnames: ${extnames} })!`, `await ${field}File.moveToDisk(''${disk})`] };
+});
+statementsRegistry.register("auth", (_value) => {
+	return {
+		logicLines: [`const user = auth.user!`],
+		context: ["auth"]
+	};
+});
+statementsRegistry.register("render", (value, { actionName, isApi, useInertia }) => {
+	const parts = value.split(" with: ");
+	const viewPath = parts[0];
+	const logicLines = [];
+	const context = [];
+	if (isApi || viewPath === "json") {
+		const responseData = parts[1] ? parts[1] : actionName === "store" || actionName === "update" ? "payload" : "data";
+		logicLines.push(`return response.json({ ${responseData} })`);
+	} else if (useInertia) {
+		const data = parts[1] ? `, { ${parts[1]} }` : "";
+		logicLines.push(`return inertia.render('${viewPath}'${data})`);
+		context.push("inertia");
+	} else {
+		const data = parts[1] ? `, { ${parts[1]} }` : "";
+		logicLines.push(`return view.render('${viewPath}'${data})`);
+		context.push("view");
+	}
+	return {
+		logicLines,
+		context
+	};
+});
+statementsRegistry.register("redirect", (value) => {
+	return { logicLines: [`return response.redirect().toRoute('${value}')`] };
+});
+statementsRegistry.register("flash", (value) => {
+	return {
+		logicLines: [`session.flash('${value}', 'Success!')`],
+		context: ["session"]
+	};
+});
+statementsRegistry.register("service", async (value, { generators }) => {
+	const parts = value.split(".");
+	const serviceClass = parts[0];
+	const method = parts[1] || "handle";
+	await generators.service.generate(serviceClass);
+	return {
+		logicLines: [`await ${serviceClass}.${method}(payload)`],
+		imports: { services: [serviceClass] }
+	};
+});
+//#endregion
+//#region src/generators/controller_generator.ts
+var ControllerGenerator = class extends BaseGenerator {
+	async generate(name, definition, useInertia = false, isApi = false, models) {
+		const nameParts = name.split(/[\/.]/);
+		const baseName = nameParts.pop();
+		const entity = this.app.generators.createEntity(baseName);
+		if (nameParts.length > 0) entity.path = nameParts.map((p) => string.snakeCase(p)).join("/");
+		const eventGenerator = new EventGenerator(this.app, this.logger, this.manifest);
+		const mailGenerator = new MailGenerator(this.app, this.logger, this.manifest);
+		const jobGenerator = new JobGenerator(this.app, this.logger, this.manifest);
+		const notificationGenerator = new NotificationGenerator(this.app, this.logger, this.manifest);
+		const serviceGenerator = new ServiceGenerator(this.app, this.logger, this.manifest);
+		const actions = [];
+		const imports = {
+			models: /* @__PURE__ */ new Set(),
+			validators: /* @__PURE__ */ new Set(),
+			events: /* @__PURE__ */ new Set(),
+			policies: /* @__PURE__ */ new Set(),
+			mails: /* @__PURE__ */ new Set(),
+			jobs: /* @__PURE__ */ new Set(),
+			notifications: /* @__PURE__ */ new Set(),
+			services: /* @__PURE__ */ new Map()
+		};
+		const middleware = definition.middleware || [];
+		const pluralName = string.plural(string.camelCase(entity.name));
+		const singularName = string.camelCase(entity.name);
+		let normalizedDefinition = definition;
+		if (definition.resource) normalizedDefinition = isApi ? {
+			index: {
+				query: "all",
+				render: "json"
+			},
+			store: {
+				validate: "all",
+				save: true,
+				render: "json"
+			},
+			show: {
+				query: "find",
+				render: "json"
+			},
+			update: {
+				validate: "all",
+				save: true,
+				render: "json"
+			},
+			destroy: {
+				delete: true,
+				render: "json"
+			}
+		} : {
+			index: { render: `${pluralName}/index` },
+			create: { render: `${pluralName}/create` },
+			store: {
+				validate: "all",
+				save: true,
+				redirect: `${pluralName}.index`
+			},
+			show: { render: `${pluralName}/show` },
+			edit: { render: `${pluralName}/edit` },
+			update: {
+				validate: "all",
+				save: true,
+				redirect: `${pluralName}.index`
+			},
+			destroy: {
+				delete: true,
+				redirect: `${pluralName}.index`
+			}
+		};
+		const generators = {
+			event: eventGenerator,
+			mail: mailGenerator,
+			job: jobGenerator,
+			notification: notificationGenerator,
+			service: serviceGenerator
+		};
+		for (const [actionName, actionDef] of Object.entries(normalizedDefinition)) {
+			if (actionName === "resource" || actionName === "middleware" || actionName === "stub") continue;
+			const contextItems = new Set(["request", "response"]);
+			let logicLines = [];
+			if (typeof actionDef === "object" && actionDef !== null) {
+				const typedDef = actionDef;
+				const order = [
+					"auth",
+					"authorize",
+					"validate",
+					"query",
+					"save",
+					"delete",
+					"fire",
+					"send",
+					"dispatch",
+					"notify",
+					"upload",
+					"flash",
+					"render",
+					"redirect"
+				];
+				const keys = Object.keys(typedDef).sort((a, b) => {
+					const idxA = order.indexOf(a);
+					const idxB = order.indexOf(b);
+					if (idxA === -1 && idxB === -1) return 0;
+					if (idxA === -1) return 1;
+					if (idxB === -1) return -1;
+					return idxA - idxB;
+				});
+				for (const key of keys) {
+					const handler = statementsRegistry.get(key);
+					if (handler) {
+						const result = await handler(typedDef[key], {
+							actionName,
+							actionDef,
+							entity,
+							isApi,
+							useInertia,
+							pluralName,
+							singularName,
+							generators,
+							models
+						});
+						logicLines.push(...result.logicLines);
+						if (result.imports) {
+							if (result.imports.models) result.imports.models.forEach((i) => imports.models.add(i));
+							if (result.imports.validators) result.imports.validators.forEach((i) => imports.validators.add(i));
+							if (result.imports.events) result.imports.events.forEach((i) => imports.events.add(i));
+							if (result.imports.policies) result.imports.policies.forEach((i) => imports.policies.add(i));
+							if (result.imports.mails) result.imports.mails.forEach((i) => imports.mails.add(i));
+							if (result.imports.jobs) result.imports.jobs.forEach((i) => imports.jobs.add(i));
+							if (result.imports.notifications) result.imports.notifications.forEach((i) => imports.notifications.add(i));
+							if (result.imports.services) result.imports.services.forEach((serviceName) => {
+								const servicePath = string.snakeCase(serviceName.replace("Service", "")) + "_service";
+								imports.services.set(serviceName, servicePath);
+							});
+						}
+						if (result.context) result.context.forEach((c) => contextItems.add(c));
+					}
+				}
+			}
+			actions.push({
+				name: actionName,
+				context: Array.from(contextItems).join(", "),
+				logic: logicLines.join("\n    ") || "// Action logic here"
+			});
+		}
+		await this.generateStub("make/controller/main.stub", {
+			entity,
+			actions,
+			middleware,
+			imports: {
+				models: Array.from(imports.models),
+				validators: Array.from(imports.validators),
+				events: Array.from(imports.events),
+				policies: Array.from(imports.policies),
+				mails: Array.from(imports.mails),
+				jobs: Array.from(imports.jobs),
+				notifications: Array.from(imports.notifications),
+				services: Array.from(imports.services.entries()).map(([serviceName, path]) => ({
+					name: serviceName,
+					path
+				}))
+			}
+		}, definition.stub);
+	}
+};
+//#endregion
+export { ControllerGenerator };

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

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

package/build/src/generators/enum_generator.js

@@ -0,0 +1,17 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/enum_generator.ts
+var EnumGenerator = class extends BaseGenerator {
+	async generate(name, definition) {
+		const entity = this.app.generators.createEntity(name);
+		const values = definition.values.map((val) => ({
+			key: val.toUpperCase(),
+			value: val
+		}));
+		await this.generateStub("make/enum/main.stub", {
+			entity,
+			values
+		});
+	}
+};
+//#endregion
+export { EnumGenerator };

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

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

package/build/src/generators/event_generator.js

@@ -0,0 +1,10 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/event_generator.ts
+var EventGenerator = class extends BaseGenerator {
+	async generate(name, _definition) {
+		const entity = this.app.generators.createEntity(name);
+		await this.generateStub("make/event/main.stub", { entity });
+	}
+};
+//#endregion
+export { EventGenerator };

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

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

package/build/src/generators/factory_generator.js

@@ -0,0 +1,50 @@
+import { BaseGenerator } from "./base_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/factory_generator.ts
+var FactoryGenerator = class extends BaseGenerator {
+	async generate(name, definition) {
+		const entity = this.app.generators.createEntity(name);
+		const attributes = [];
+		const relationships = [];
+		const factoryImports = /* @__PURE__ */ new Set();
+		if (definition.attributes) for (const [attrName, attrType] of Object.entries(definition.attributes)) {
+			let fakerMethod = "lorem.word";
+			const typeStr = typeof attrType === "string" ? attrType : attrType.type || "string";
+			if (typeStr.includes("faker:")) fakerMethod = typeStr.split("faker:")[1].split(":")[0];
+			else if (attrName.includes("first_name")) fakerMethod = "person.firstName";
+			else if (attrName.includes("last_name")) fakerMethod = "person.lastName";
+			else if (attrName.includes("full_name") || attrName === "name") fakerMethod = "person.fullName";
+			else if (attrName === "email") fakerMethod = "internet.email";
+			else if (attrName.includes("password")) fakerMethod = "internet.password";
+			else if (attrName.includes("phone")) fakerMethod = "phone.number";
+			else if (attrName.includes("city")) fakerMethod = "location.city";
+			else if (attrName.includes("country")) fakerMethod = "location.country";
+			else if (attrName.includes("address")) fakerMethod = "location.streetAddress";
+			else if (typeStr.startsWith("string") || typeStr.startsWith("text")) fakerMethod = "lorem.sentence";
+			else if (typeStr.startsWith("integer") || typeStr.startsWith("number")) fakerMethod = "number.int";
+			else if (typeStr.startsWith("boolean")) fakerMethod = "datatype.boolean";
+			else if (typeStr.startsWith("timestamp") || typeStr.startsWith("datetime")) fakerMethod = "date.recent";
+			attributes.push({
+				name: attrName,
+				fakerMethod
+			});
+		}
+		if (definition.relationships) for (const [relName, relType] of Object.entries(definition.relationships)) {
+			const relatedModel = string.pascalCase(string.singular(relName));
+			relationships.push({
+				name: relName,
+				type: relType,
+				model: relatedModel
+			});
+			if (relType === "hasMany" || relType === "belongsToMany") factoryImports.add(`${relatedModel}Factory`);
+		}
+		await this.generateStub("make/factory/main.stub", {
+			entity,
+			attributes,
+			relationships,
+			factoryImports: Array.from(factoryImports)
+		});
+	}
+};
+//#endregion
+export { FactoryGenerator };

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

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

package/build/src/generators/job_generator.js

@@ -0,0 +1,10 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/job_generator.ts
+var JobGenerator = class extends BaseGenerator {
+	async generate(name, _definition) {
+		const entity = this.app.generators.createEntity(name);
+		await this.generateStub("make/job/main.stub", { entity });
+	}
+};
+//#endregion
+export { JobGenerator };

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

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

package/build/src/generators/mail_generator.js

@@ -0,0 +1,10 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/mail_generator.ts
+var MailGenerator = class extends BaseGenerator {
+	async generate(name, _definition) {
+		const entity = this.app.generators.createEntity(name);
+		await this.generateStub("make/mail/main.stub", { entity });
+	}
+};
+//#endregion
+export { MailGenerator };

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

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

package/build/src/generators/middleware_generator.js

@@ -0,0 +1,10 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/middleware_generator.ts
+var MiddlewareGenerator = class extends BaseGenerator {
+	async generate(name, _definition) {
+		const entity = this.app.generators.createEntity(name);
+		await this.generateStub("make/middleware/main.stub", { entity });
+	}
+};
+//#endregion
+export { MiddlewareGenerator };

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

@@ -0,0 +1,5 @@
+import { BaseGenerator } from './base_generator.js';
+export declare class MigrationGenerator extends BaseGenerator {
+    generate(name: string, definition: any): Promise<void>;
+    private generatePivotMigration;
+}

package/build/src/generators/migration_generator.js

@@ -0,0 +1,46 @@
+import { BaseGenerator } from "./base_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/migration_generator.ts
+var MigrationGenerator = class extends BaseGenerator {
+	async generate(name, definition) {
+		const entity = this.app.generators.createEntity(name);
+		const attributes = [];
+		const processedAttributes = /* @__PURE__ */ new Set();
+		if (definition.attributes) for (const [attrName, attrType] of Object.entries(definition.attributes)) {
+			let migrationLine = "";
+			if (typeof attrType === "string") if (attrType === "foreign") migrationLine = `table.integer('${attrName}').unsigned().references('id').inTable('${string.plural(attrName.replace("_id", ""))}')`;
+			else if (attrType.startsWith("enum:")) migrationLine = `table.enum('${attrName}', [${attrType.split(":")[1].split(",").map((v) => `'${v.trim()}'`).join(", ")}])`;
+			else migrationLine = `table.${attrType}('${attrName}')`;
+			attributes.push({ migrationLine });
+			processedAttributes.add(attrName);
+		}
+		if (definition.relationships) {
+			for (const [relName, relType] of Object.entries(definition.relationships)) if (relType === "belongsTo" && !processedAttributes.has(`${relName}_id`)) attributes.push({ migrationLine: `table.integer('${relName}_id').unsigned().references('id').inTable('${string.plural(relName)}').onDelete('CASCADE')` });
+		}
+		if (definition.softDeletes) attributes.push({ migrationLine: `table.timestamp('deleted_at')` });
+		await this.generateStub("make/migration/main.stub", {
+			entity: {
+				...entity,
+				tableName: string.plural(string.snakeCase(entity.name))
+			},
+			attributes
+		});
+		if (definition.relationships) {
+			for (const [relName, relType] of Object.entries(definition.relationships)) if (relType === "belongsToMany") await this.generatePivotMigration(entity.name, relName);
+		}
+	}
+	async generatePivotMigration(modelA, modelB) {
+		const models = [string.snakeCase(modelA), string.snakeCase(modelB)].sort();
+		const tableName = `${models[0]}_${models[1]}`;
+		const entity = this.app.generators.createEntity(tableName);
+		await this.generateStub("make/migration/main.stub", {
+			entity: {
+				...entity,
+				tableName
+			},
+			attributes: [{ migrationLine: `table.integer('${models[0]}_id').unsigned().references('id').inTable('${string.plural(models[0])}').onDelete('CASCADE')` }, { migrationLine: `table.integer('${models[1]}_id').unsigned().references('id').inTable('${string.plural(models[1])}').onDelete('CASCADE')` }]
+		});
+	}
+};
+//#endregion
+export { MigrationGenerator };

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

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

package/build/src/generators/model_generator.js

@@ -0,0 +1,57 @@
+import { BaseGenerator } from "./base_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/model_generator.ts
+var ModelGenerator = class extends BaseGenerator {
+	async generate(name, definition) {
+		const entity = this.app.generators.createEntity(name);
+		const relationships = [];
+		const attributes = [];
+		const processedAttributes = /* @__PURE__ */ new Set();
+		let modelImports = `import { DateTime } from 'luxon'\nimport { column } from '@adonisjs/lucid/orm'\nimport { BaseModel } from '@adonisjs/lucid/orm'`;
+		let modelSignature = `export default class ${entity.className} extends BaseModel {`;
+		if (definition.softDeletes) {
+			modelImports = `import { DateTime } from 'luxon'\nimport { column } from '@adonisjs/lucid/orm'\nimport { BaseModel } from '@adonisjs/lucid/orm'\nimport { compose } from '@adonisjs/core/helpers'\nimport { withSoftDeletes } from '@adonisjs/lucid-soft-deletes'`;
+			modelSignature = `export default class ${entity.className} extends compose(BaseModel, withSoftDeletes) {`;
+		}
+		if (definition.attributes) for (const [attrName, attrType] of Object.entries(definition.attributes)) {
+			let tsType = "string";
+			let columnDecorator = "@column()";
+			const baseType = (typeof attrType === "string" ? attrType : attrType.type || "string").split(":")[0];
+			if (baseType === "number" || baseType === "integer") tsType = "number";
+			else if (baseType === "boolean") tsType = "boolean";
+			else if (baseType === "timestamp" || baseType === "datetime") {
+				tsType = "DateTime";
+				columnDecorator = "@column.dateTime({ autoCreate: true, autoUpdate: true })";
+			} else if (baseType === "enum") tsType = "any";
+			attributes.push({ line: `${columnDecorator}\ndeclare ${attrName}: ${tsType}` });
+			processedAttributes.add(attrName);
+		}
+		if (definition.relationships) for (const [relName, relType] of Object.entries(definition.relationships)) {
+			const relatedModelName = string.pascalCase(string.singular(relName));
+			let relationshipLine = `@${relType}(() => ${relatedModelName})\ndeclare ${relName}: ${relType.charAt(0).toUpperCase() + relType.slice(1)}<typeof ${relatedModelName}>`;
+			if (relType === "belongsToMany") relationshipLine = `@${relType}(() => ${relatedModelName}, { pivotTable: '${[entity.className, relatedModelName].sort().map((m) => string.snakeCase(m)).join("_")}' })\ndeclare ${relName}: ${relType.charAt(0).toUpperCase() + relType.slice(1)}<typeof ${relatedModelName}>`;
+			if (relType === "belongsTo") {
+				const foreignKey = `${string.camelCase(relName)}Id`;
+				if (!processedAttributes.has(foreignKey)) {
+					attributes.push({ line: `@column()\ndeclare ${foreignKey}: number` });
+					processedAttributes.add(foreignKey);
+				}
+			}
+			relationships.push({
+				importLine: `import { ${relType} } from '@adonisjs/lucid/orm'\nimport type { ${relType.charAt(0).toUpperCase() + relType.slice(1)} } from '@adonisjs/lucid/types'\nimport ${relatedModelName} from '#models/${string.snakeCase(relatedModelName)}'`,
+				line: relationshipLine
+			});
+		}
+		if (!processedAttributes.has("createdAt")) attributes.push({ line: "@column.dateTime({ autoCreate: true })\ndeclare createdAt: DateTime" });
+		if (!processedAttributes.has("updatedAt")) attributes.push({ line: "@column.dateTime({ autoCreate: true, autoUpdate: true })\ndeclare updatedAt: DateTime" });
+		await this.generateStub("make/model/main.stub", {
+			entity,
+			attributes,
+			relationships,
+			modelImports,
+			modelSignature
+		}, definition.stub);
+	}
+};
+//#endregion
+export { ModelGenerator };

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

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

package/build/src/generators/notification_generator.js

@@ -0,0 +1,10 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/notification_generator.ts
+var NotificationGenerator = class extends BaseGenerator {
+	async generate(name, _definition) {
+		const entity = this.app.generators.createEntity(name);
+		await this.generateStub("make/notification/main.stub", { entity });
+	}
+};
+//#endregion
+export { NotificationGenerator };

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

@@ -0,0 +1,8 @@
+import { BaseGenerator } from './base_generator.js';
+import type { BlueprintSchema } from '../types.js';
+export declare class OpenAPIGenerator extends BaseGenerator {
+    generate(_name: string, blueprint: BlueprintSchema): Promise<void>;
+    private mapToOpenAPIType;
+    private normalizeDefinition;
+    private inferRoute;
+}