@anu8151/adonisjs-blueprint 0.2.0

package/build/src/generators/openapi_generator.js

@@ -0,0 +1,200 @@
+import { BaseGenerator } from "./base_generator.js";
+import { writeFileSync } from "node:fs";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/openapi_generator.ts
+var OpenAPIGenerator = class extends BaseGenerator {
+	async generate(_name, blueprint) {
+		if (!blueprint.controllers) return;
+		const openapi = {
+			openapi: "3.0.0",
+			info: {
+				title: blueprint.settings?.api ? "AdonisJS API Documentation" : "AdonisJS Application API",
+				version: "1.0.0"
+			},
+			paths: {},
+			components: {
+				schemas: {},
+				securitySchemes: { bearerAuth: {
+					type: "http",
+					scheme: "bearer",
+					bearerFormat: "JWT"
+				} }
+			}
+		};
+		if (blueprint.models) for (const [modelName, modelDef] of Object.entries(blueprint.models)) {
+			const schema = {
+				type: "object",
+				properties: {},
+				required: []
+			};
+			if (modelDef.attributes) for (const [attrName, attrType] of Object.entries(modelDef.attributes)) {
+				const typeStr = typeof attrType === "string" ? attrType : attrType.type || "string";
+				schema.properties[attrName] = { type: this.mapToOpenAPIType(typeStr) };
+				if (typeof attrType === "string" && !attrType.includes("optional") && !attrType.includes("nullable")) schema.required.push(attrName);
+			}
+			if (schema.required.length === 0) delete schema.required;
+			openapi.components.schemas[modelName] = schema;
+		}
+		for (const [controllerName, controllerDef] of Object.entries(blueprint.controllers)) {
+			const resourceName = string.snakeCase(controllerName);
+			const normalizedDefinition = this.normalizeDefinition(controllerDef, blueprint.settings?.api, controllerName);
+			const modelName = string.pascalCase(string.singular(controllerName));
+			for (const [actionName, actionDef] of Object.entries(normalizedDefinition)) {
+				if (actionName === "resource" || actionName === "middleware" || actionName === "stub") continue;
+				const { path, method } = this.inferRoute(resourceName, actionName);
+				if (!path || !method) continue;
+				if (!openapi.paths[path]) openapi.paths[path] = {};
+				const operation = {
+					tags: [controllerName],
+					summary: `${actionName} action for ${controllerName}`,
+					responses: { "200": { description: "Successful response" } }
+				};
+				if (path.includes("{id}")) operation.parameters = [{
+					name: "id",
+					in: "path",
+					required: true,
+					schema: { type: "string" }
+				}];
+				if (actionDef.auth) operation.security = [{ bearerAuth: [] }];
+				if (actionDef.validate) {
+					const validateFields = actionDef.validate === "all" ? Object.keys(blueprint.models?.[modelName]?.attributes || {}) : actionDef.validate.split(",").map((f) => f.trim());
+					operation.requestBody = { content: { "application/json": { schema: {
+						type: "object",
+						properties: {}
+					} } } };
+					for (const field of validateFields) {
+						const attrType = blueprint.models?.[modelName]?.attributes?.[field];
+						const typeStr = typeof attrType === "string" ? attrType : attrType?.type || "string";
+						operation.requestBody.content["application/json"].schema.properties[field] = { type: this.mapToOpenAPIType(typeStr) };
+					}
+				} else if (actionName === "store" || actionName === "update") operation.requestBody = { content: { "application/json": { schema: { $ref: `#/components/schemas/${modelName}` } } } };
+				if (actionDef.query === "all" || actionDef.query?.startsWith("paginate")) {
+					operation.responses["200"].content = { "application/json": { schema: {
+						type: "array",
+						items: { $ref: `#/components/schemas/${modelName}` }
+					} } };
+					if (actionDef.query.startsWith("paginate")) {
+						if (!operation.parameters) operation.parameters = [];
+						operation.parameters.push({
+							name: "page",
+							in: "query",
+							schema: {
+								type: "integer",
+								default: 1
+							}
+						}, {
+							name: "limit",
+							in: "query",
+							schema: {
+								type: "integer",
+								default: 20
+							}
+						});
+					}
+				} else if (actionDef.query === "find") operation.responses["200"].content = { "application/json": { schema: { $ref: `#/components/schemas/${modelName}` } } };
+				openapi.paths[path][method] = operation;
+			}
+		}
+		const outputPath = this.app.makePath("openapi.json");
+		writeFileSync(outputPath, JSON.stringify(openapi, null, 2));
+		this.logger.action(`create ${outputPath}`).succeeded();
+		if (this.manifest) this.manifest.push(outputPath);
+	}
+	mapToOpenAPIType(type) {
+		switch (type.split(":")[0]) {
+			case "integer":
+			case "number": return "number";
+			case "boolean": return "boolean";
+			case "datetime":
+			case "timestamp":
+			case "date": return "string";
+			default: return "string";
+		}
+	}
+	normalizeDefinition(definition, isApi, controllerName) {
+		if (definition.resource) {
+			const pluralName = string.plural(string.camelCase(controllerName || ""));
+			return 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`
+				}
+			};
+		}
+		return definition;
+	}
+	inferRoute(resourceName, actionName) {
+		return {
+			index: {
+				path: `/${resourceName}`,
+				method: "get"
+			},
+			create: {
+				path: `/${resourceName}/create`,
+				method: "get"
+			},
+			store: {
+				path: `/${resourceName}`,
+				method: "post"
+			},
+			show: {
+				path: `/${resourceName}/{id}`,
+				method: "get"
+			},
+			edit: {
+				path: `/${resourceName}/{id}/edit`,
+				method: "get"
+			},
+			update: {
+				path: `/${resourceName}/{id}`,
+				method: "put"
+			},
+			destroy: {
+				path: `/${resourceName}/{id}`,
+				method: "delete"
+			}
+		}[actionName] || {
+			path: `/${resourceName}/${string.snakeCase(actionName)}`,
+			method: "get"
+		};
+	}
+};
+//#endregion
+export { OpenAPIGenerator };

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

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

package/build/src/generators/policy_generator.js

@@ -0,0 +1,29 @@
+import { BaseGenerator } from "./base_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/policy_generator.ts
+var PolicyGenerator = class extends BaseGenerator {
+	async generate(name, definition) {
+		const entity = this.app.generators.createEntity(name);
+		const actions = [];
+		for (const [actionName, actionDef] of Object.entries(definition)) {
+			if (typeof actionDef !== "object") continue;
+			let policyAction = actionName;
+			if (actionName === "index") policyAction = "viewAny";
+			if (actionName === "show") policyAction = "view";
+			if (actionName === "store") policyAction = "create";
+			if (actionName === "update") policyAction = "update";
+			if (actionName === "destroy") policyAction = "delete";
+			actions.push({
+				name: policyAction,
+				modelName: entity.className,
+				variableName: string.camelCase(entity.className)
+			});
+		}
+		await this.generateStub("make/policy/main.stub", {
+			entity,
+			actions
+		});
+	}
+};
+//#endregion
+export { PolicyGenerator };

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

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

package/build/src/generators/route_generator.js

@@ -0,0 +1,34 @@
+import { BaseGenerator } from "./base_generator.js";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/generators/route_generator.ts
+var RouteGenerator = class extends BaseGenerator {
+	async generate(name, definition, isApi = false) {
+		const nameParts = name.split(/[\/.]/);
+		const baseName = nameParts.pop();
+		const parents = nameParts.map((p) => p.toLowerCase() + "s");
+		const entity = this.app.generators.createEntity(baseName);
+		const routesPath = this.app.makePath("start/routes.ts");
+		if (!existsSync(routesPath)) {
+			this.logger.warning(`File ${routesPath} not found. Skipping route registration.`);
+			return;
+		}
+		const resourceName = entity.name.toLowerCase() + "s";
+		const fullResourcePath = [...parents, resourceName].join(".");
+		const controllerPath = [...nameParts.map((p) => p.toLowerCase()), entity.name.toLowerCase()].join("/");
+		let content = readFileSync(routesPath, "utf8");
+		if (content.includes(`router.resource('${fullResourcePath}'`)) return;
+		let routeLine = `router.resource('${fullResourcePath}', '#controllers/${controllerPath}_controller')`;
+		if (isApi) routeLine += ".apiOnly()";
+		if (definition.middleware && definition.middleware.length > 0) {
+			const mw = definition.middleware.map((m) => `middleware.${m}()`).join(", ");
+			routeLine += `.use('*', [${mw}])`;
+		}
+		if (nameParts.length > 0) {
+			const prefix = nameParts.map((p) => p.toLowerCase()).join("/");
+			writeFileSync(routesPath, content + `\nrouter.group(() => {\n  ${routeLine}\n}).prefix('${prefix}')`);
+		} else writeFileSync(routesPath, content + `\n${routeLine}`);
+		this.logger.success(`Registered resource routes for ${fullResourcePath}`);
+	}
+};
+//#endregion
+export { RouteGenerator };

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

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

package/build/src/generators/seeder_generator.js

@@ -0,0 +1,16 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/seeder_generator.ts
+var SeederGenerator = class extends BaseGenerator {
+	async generate(name, definition) {
+		const entity = this.app.generators.createEntity(name);
+		const count = definition.seed || 10;
+		const data = definition.data || null;
+		await this.generateStub("make/seeder/main.stub", {
+			entity,
+			count,
+			data
+		});
+	}
+};
+//#endregion
+export { SeederGenerator };

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

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

package/build/src/generators/service_generator.js

@@ -0,0 +1,14 @@
+import { BaseGenerator } from "./base_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/service_generator.ts
+var ServiceGenerator = class extends BaseGenerator {
+	async generate(name) {
+		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("/");
+		await this.generateStub("make/service/main.stub", { entity });
+	}
+};
+//#endregion
+export { ServiceGenerator };

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

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

package/build/src/generators/test_generator.js

@@ -0,0 +1,38 @@
+import { BaseGenerator } from "./base_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/test_generator.ts
+var TestGenerator = class extends BaseGenerator {
+	async generate(name, definition, blueprint) {
+		const entity = this.app.generators.createEntity(name);
+		const actions = [];
+		const pluralName = string.plural(string.snakeCase(entity.name));
+		for (const [actionName, actionDef] of Object.entries(definition)) {
+			if (typeof actionDef !== "object") continue;
+			let method = "get";
+			let url = `/${pluralName}`;
+			const typedDef = actionDef;
+			if (actionName === "store") method = "post";
+			else if (actionName === "show" || actionName === "edit") url = `/${pluralName}/1`;
+			else if (actionName === "update") {
+				method = "put";
+				url = `/${pluralName}/1`;
+			} else if (actionName === "destroy") {
+				method = "delete";
+				url = `/${pluralName}/1`;
+			} else if (actionName === "create") url = `/${pluralName}/create`;
+			actions.push({
+				name: actionName,
+				method,
+				url,
+				auth: !!typedDef.auth
+			});
+		}
+		await this.generateStub("make/test/controller.stub", {
+			entity,
+			actions,
+			hasAuth: actions.some((a) => a.auth) || !!blueprint.auth
+		});
+	}
+};
+//#endregion
+export { TestGenerator };

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

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

package/build/src/generators/validator_generator.js

@@ -0,0 +1,70 @@
+import { BaseGenerator } from "./base_generator.js";
+import string from "@adonisjs/core/helpers/string";
+//#region src/generators/validator_generator.ts
+var ValidatorGenerator = class extends BaseGenerator {
+	async generate(name, definition) {
+		const entity = this.app.generators.createEntity(name);
+		const attributes = [];
+		if (definition.attributes) for (const [attrName, attrType] of Object.entries(definition.attributes)) {
+			let vineChain = "vine.string()";
+			const parts = (typeof attrType === "string" ? attrType : attrType.type || "string").split(":");
+			const baseType = parts[0];
+			if (baseType === "number" || baseType === "integer") vineChain = "vine.number()";
+			else if (baseType === "boolean") vineChain = "vine.boolean()";
+			else if (baseType === "email") vineChain = "vine.string().email()";
+			else if (baseType === "url") vineChain = "vine.string().url()";
+			else if (baseType === "ip") vineChain = "vine.string().ip()";
+			else if (baseType === "uuid") vineChain = "vine.string().uuid()";
+			else if (baseType === "mobile") vineChain = "vine.string().mobile()";
+			else if (baseType === "postalCode") vineChain = "vine.string().postalCode()";
+			else if (baseType === "creditCard") vineChain = "vine.string().creditCard()";
+			else if (baseType === "macAddress") vineChain = "vine.string().macAddress()";
+			for (let i = 1; i < parts.length; i++) {
+				const modifier = parts[i];
+				if (modifier === "unique") {
+					const tableName = string.plural(string.snakeCase(entity.name));
+					const scope = parts.find((p) => p.startsWith("scope:"));
+					if (scope) {
+						const scopeColumn = scope.replace("scope:", "");
+						vineChain += `.unique(async (db, value, field) => { 
+                const query = db.from('${tableName}').where('${attrName}', value)
+                if (field.meta.id) query.whereNot('id', field.meta.id)
+                const scopeValue = field.meta['${scopeColumn}'] || field.data['${scopeColumn}']
+                if (scopeValue) query.where('${scopeColumn}', scopeValue)
+                return !await query.first() 
+              })`;
+					} else vineChain += `.unique(async (db, value, field) => { 
+                const query = db.from('${tableName}').where('${attrName}', value)
+                if (field.meta.id) query.whereNot('id', field.meta.id)
+                return !await query.first() 
+              })`;
+				} else if (modifier === "min" && parts[i + 1]) {
+					vineChain += baseType === "number" ? `.min(${parts[i + 1]})` : `.minLength(${parts[i + 1]})`;
+					i++;
+				} else if (modifier === "max" && parts[i + 1]) {
+					vineChain += baseType === "number" ? `.max(${parts[i + 1]})` : `.maxLength(${parts[i + 1]})`;
+					i++;
+				} else if (modifier === "optional" || modifier === "nullable") vineChain += ".optional()";
+				else if (modifier === "confirmed") vineChain += ".confirmed()";
+				else if (modifier === "regex" && parts[i + 1]) {
+					vineChain += `.regex(new RegExp('${parts[i + 1]}'))`;
+					i++;
+				}
+			}
+			attributes.push({
+				name: attrName,
+				vineType: vineChain.replace("vine.", "")
+			});
+			if (parts.includes("confirmed")) attributes.push({
+				name: `${attrName}_confirmation`,
+				vineType: vineChain.replace("vine.", "").replace(".confirmed()", "")
+			});
+		}
+		await this.generateStub("make/validator/main.stub", {
+			entity,
+			attributes
+		}, definition.stub);
+	}
+};
+//#endregion
+export { ValidatorGenerator };

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

@@ -0,0 +1,4 @@
+import { BaseGenerator } from './base_generator.js';
+export declare class ViewGenerator extends BaseGenerator {
+    generate(name: string, useInertia?: boolean, adapter?: 'react' | 'vue' | 'svelte', definition?: any): Promise<void>;
+}

package/build/src/generators/view_generator.js

@@ -0,0 +1,23 @@
+import { BaseGenerator } from "./base_generator.js";
+//#region src/generators/view_generator.ts
+var ViewGenerator = class extends BaseGenerator {
+	async generate(name, useInertia = false, adapter = "react", definition) {
+		const entity = this.app.generators.createEntity(name);
+		let stubPath = "make/view/edge.stub";
+		if (useInertia) stubPath = `make/view/${adapter}.stub`;
+		const attributes = definition?.attributes ? Object.entries(definition.attributes).map(([attrName, attrType]) => ({
+			name: attrName,
+			type: typeof attrType === "string" ? attrType : attrType.type
+		})) : [];
+		const action = name.split("/").pop() || "show";
+		const folder = name.split("/").slice(0, -1).join("/");
+		await this.generateStub(stubPath, {
+			entity,
+			attributes,
+			action,
+			folder
+		});
+	}
+};
+//#endregion
+export { ViewGenerator };

package/build/src/parser.d.ts

@@ -0,0 +1,7 @@
+import type { BlueprintSchema } from './types.js';
+export declare class BlueprintParser {
+    /**
+     * Parse the given draft file and validate it against the JSON schema
+     */
+    parse(filePath: string): Promise<BlueprintSchema>;
+}

package/build/src/parser.js

@@ -0,0 +1,2 @@
+import { t as BlueprintParser } from "../parser-DJB5DEck.js";
+export { BlueprintParser };

package/build/src/statements/index.d.ts

@@ -0,0 +1 @@
+export {};

package/build/src/statements_registry.d.ts

@@ -0,0 +1,47 @@
+import type { Entity } from './types.js';
+import { type EventGenerator } from './generators/event_generator.js';
+import { type MailGenerator } from './generators/mail_generator.js';
+import { type JobGenerator } from './generators/job_generator.js';
+import { type NotificationGenerator } from './generators/notification_generator.js';
+import { type ServiceGenerator } from './generators/service_generator.js';
+export interface StatementContext {
+    actionName: string;
+    actionDef: any;
+    entity: Entity;
+    isApi: boolean;
+    useInertia: boolean;
+    pluralName: string;
+    singularName: string;
+    generators: {
+        event: EventGenerator;
+        mail: MailGenerator;
+        job: JobGenerator;
+        notification: NotificationGenerator;
+        service: ServiceGenerator;
+    };
+    models?: any;
+}
+export interface StatementResult {
+    logicLines: string[];
+    imports?: {
+        models?: string[];
+        validators?: string[];
+        events?: string[];
+        policies?: string[];
+        mails?: string[];
+        jobs?: string[];
+        notifications?: string[];
+        services?: string[];
+    };
+    context?: string[];
+}
+export type StatementHandler = (value: any, context: StatementContext) => StatementResult | Promise<StatementResult>;
+declare class StatementsRegistry {
+    private handlers;
+    register(name: string, handler: StatementHandler): void;
+    get(name: string): StatementHandler | undefined;
+    has(name: string): boolean;
+    all(): MapIterator<[string, StatementHandler]>;
+}
+export declare const statementsRegistry: StatementsRegistry;
+export {};

package/build/src/types.d.ts

@@ -0,0 +1,50 @@
+export interface Entity {
+    name: string;
+    path: string;
+    className: string;
+    tableName?: string;
+}
+export interface ModelAttribute {
+    name: string;
+    type: string;
+    modifiers: string[];
+}
+export interface ModelRelationship {
+    type: 'belongsTo' | 'hasMany' | 'belongsToMany' | 'hasOne';
+    model: string;
+}
+export interface ModelDefinition {
+    name: string;
+    attributes: Record<string, string | {
+        type: string;
+        modifiers?: string[];
+    }>;
+    relationships?: Record<string, string>;
+}
+export interface ControllerAction {
+    query?: string;
+    render?: string;
+    validate?: string;
+    save?: string | boolean;
+    flash?: string;
+    redirect?: string;
+    delete?: string | boolean;
+}
+export interface ControllerDefinition {
+    name: string;
+    middleware?: string[];
+    actions: Record<string, ControllerAction>;
+}
+export interface BlueprintSchema {
+    settings?: {
+        api?: boolean;
+        inertia?: {
+            enabled: boolean;
+            adapter: 'react' | 'vue' | 'svelte';
+        };
+    };
+    auth?: Record<string, any> | boolean;
+    models?: Record<string, any>;
+    controllers?: Record<string, any>;
+    channels?: Record<string, any>;
+}

package/build/statements_registry-DzyxAiKP.js

@@ -0,0 +1,19 @@
+//#region src/statements_registry.ts
+var StatementsRegistry = class {
+	handlers = /* @__PURE__ */ new Map();
+	register(name, handler) {
+		this.handlers.set(name, handler);
+	}
+	get(name) {
+		return this.handlers.get(name);
+	}
+	has(name) {
+		return this.handlers.has(name);
+	}
+	all() {
+		return this.handlers.entries();
+	}
+};
+const statementsRegistry = new StatementsRegistry();
+//#endregion
+export { statementsRegistry as t };

package/build/stubs/config.stub

@@ -0,0 +1,32 @@
+{{{
+  exports({
+    to: app.configPath('blueprint.ts')
+  })
+}}}
+import { defineConfig } from '@anu8151/adonisjs-blueprint'
+
+export default defineConfig({
+  /**
+   * Default view framework to use
+   * Options: 'edge', 'inertia'
+   */
+  viewer: 'edge',
+
+  /**
+   * Default Inertia adapter
+   * Options: 'react', 'vue', 'svelte'
+   */
+  inertia: {
+    adapter: 'react'
+  },
+
+  /**
+   * Custom namespaces for generated files
+   */
+  namespaces: {
+    models: 'app/models',
+    controllers: 'app/controllers',
+    validators: 'app/validators',
+    factories: 'database/factories',
+  }
+})

package/build/stubs/main.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Path to the root directory where the stubs are stored. We use
+ * this path within commands and the configure hook
+ */
+export declare const stubsRoot: string;