svelte-reflector 1.0.52 → 1.1.0

package/dist/core/Method.d.ts

@@ -0,0 +1,41 @@
+import type { ApiType } from "../types/types.js";
+import type { PrimitiveProp } from "../props/primitive.property.js";
+import type { ArrayProp } from "../props/array.property.js";
+import type { EnumProp } from "../props/enum.property.js";
+import type { ReflectorRequestType } from "../request.js";
+export type AttributeProp = PrimitiveProp | ArrayProp | EnumProp;
+export interface MethodAnalyzers {
+    request: {
+        bodyType: string | undefined;
+        responseType: string | null;
+        attributeType: ReflectorRequestType;
+        apiType: ApiType;
+        parameters: any[];
+        hasEnumResponse: boolean;
+    };
+    props: {
+        paths: PrimitiveProp[];
+        headers: PrimitiveProp[];
+        querys: AttributeProp[];
+        cookies: PrimitiveProp[];
+    };
+}
+export declare class Method {
+    name: string;
+    endpoint: string;
+    apiType: ApiType;
+    attributeType: ReflectorRequestType;
+    description: string | undefined;
+    analyzers: MethodAnalyzers;
+    responseTypeInterface: string;
+    isValid: boolean;
+    constructor(params: {
+        name: string;
+        endpoint: string;
+        apiType: ApiType;
+        attributeType: ReflectorRequestType;
+        description: string | undefined;
+        analyzers: MethodAnalyzers;
+        responseTypeInterface: string;
+    });
+}

package/dist/core/Method.js

@@ -0,0 +1,19 @@
+export class Method {
+    name;
+    endpoint;
+    apiType;
+    attributeType;
+    description = undefined;
+    analyzers;
+    responseTypeInterface;
+    isValid = true;
+    constructor(params) {
+        this.name = params.name;
+        this.endpoint = params.endpoint;
+        this.apiType = params.apiType;
+        this.attributeType = params.attributeType;
+        this.description = params.description;
+        this.analyzers = params.analyzers;
+        this.responseTypeInterface = params.responseTypeInterface;
+    }
+}

package/dist/core/MethodApiTypeAnalyzer.d.ts

@@ -0,0 +1,9 @@
+import type { ReflectorOperation, ApiType } from "../types/types.js";
+import type { ReflectorRequestType } from "../request.js";
+export declare class MethodApiTypeAnalyzer {
+    analyze(operation: ReflectorOperation): {
+        apiType: ApiType;
+        attributeType: ReflectorRequestType;
+    };
+    private inferAttributeType;
+}

package/dist/core/MethodApiTypeAnalyzer.js

@@ -0,0 +1,19 @@
+export class MethodApiTypeAnalyzer {
+    analyze(operation) {
+        const apiType = operation.apiMethod;
+        const attributeType = this.inferAttributeType(operation);
+        return { apiType, attributeType };
+    }
+    inferAttributeType(operation) {
+        const method = operation.apiMethod;
+        if (method === "post" || method === "put" || method === "patch") {
+            return "form";
+        }
+        if (method === "get") {
+            const params = operation.parameters ?? [];
+            const hasPage = params.some((p) => !("$ref" in p) && p.name === "page");
+            return hasPage ? "list" : "entity";
+        }
+        return "other";
+    }
+}

package/dist/core/MethodBodyAnalyzer.d.ts

@@ -0,0 +1,11 @@
+import type { ReflectorOperation } from "../types/types.js";
+export declare class MethodBodyAnalyzer {
+    bodyType?: string;
+    analyze(operation: ReflectorOperation): string | undefined;
+    private getTypeFromRequestBody;
+    private isRef;
+    private componentName;
+    private getFromContent;
+    private typeFromSchemaOrType;
+    private typeFromProperties;
+}

package/dist/core/MethodBodyAnalyzer.js

@@ -0,0 +1,78 @@
+export class MethodBodyAnalyzer {
+    bodyType;
+    analyze(operation) {
+        const body = this.getTypeFromRequestBody(operation.requestBody);
+        if (body)
+            this.bodyType = body;
+        return this.bodyType;
+    }
+    getTypeFromRequestBody(requestBody) {
+        if (!requestBody || this.isRef(requestBody))
+            return undefined;
+        const schemaOrType = this.getFromContent(requestBody.content);
+        return this.typeFromSchemaOrType(schemaOrType);
+    }
+    isRef(v) {
+        return !!v && typeof v === "object" && "$ref" in v;
+    }
+    componentName(refObj) {
+        const parts = refObj.$ref.split("/");
+        return parts[parts.length - 1];
+    }
+    getFromContent(content) {
+        if (!content || this.isRef(content))
+            return undefined;
+        const first = Object.values(content)[0];
+        const schema = first?.schema;
+        if (!schema)
+            return undefined;
+        if (this.isRef(schema))
+            return this.componentName(schema);
+        return schema;
+    }
+    typeFromSchemaOrType(schemaOrType) {
+        if (!schemaOrType)
+            return undefined;
+        if (typeof schemaOrType === "string")
+            return schemaOrType;
+        const schema = schemaOrType;
+        if (schema.enum) {
+            const enumName = schema["x-enumNames"];
+            if (Array.isArray(enumName))
+                return schema.title || "string";
+            return schema.title || enumName || "string";
+        }
+        const allOfFirst = schema.allOf?.[0];
+        if (allOfFirst && !this.isRef(allOfFirst)) {
+            const t = this.typeFromProperties(allOfFirst.properties);
+            if (t !== undefined)
+                return t;
+        }
+        if (schema.type === "array" && schema.items) {
+            const items = schema.items;
+            if (this.isRef(items))
+                return this.componentName(items);
+            if (items.enum)
+                return items.title || items["x-enumNames"] || "string";
+            return items.type;
+        }
+        if (schema.properties) {
+            const t = this.typeFromProperties(schema.properties);
+            if (t !== undefined)
+                return t;
+        }
+        return schema.type;
+    }
+    typeFromProperties(properties) {
+        if (!properties?.["data"])
+            return undefined;
+        const data = properties["data"];
+        if (this.isRef(data))
+            return this.componentName(data);
+        if (data.type === "any")
+            return undefined;
+        if (data.enum)
+            return data.title || data["x-enumNames"] || "string";
+        return data.type;
+    }
+}

package/dist/core/MethodBuilder.d.ts

@@ -0,0 +1,11 @@
+import type { ReflectorOperation } from "../types/types.js";
+import { Method } from "./Method.js";
+export declare class MethodBuilder {
+    private readonly requestAnalyzer;
+    private readonly responseAnalyzer;
+    private readonly apiTypeAnalyzer;
+    private readonly bodyAnalyzer;
+    build(operation: ReflectorOperation, moduleName: string): Method;
+    private extractName;
+    private buildResponseTypeInterface;
+}

package/dist/core/MethodBuilder.js

@@ -0,0 +1,50 @@
+import { Method } from "./Method.js";
+import { MethodRequestAnalyzer } from "./MethodRequestAnalyzer.js";
+import { MethodResponseAnalyzer } from "./MethodResponseAnalyzer.js";
+import { MethodApiTypeAnalyzer } from "./MethodApiTypeAnalyzer.js";
+import { MethodBodyAnalyzer } from "./MethodBodyAnalyzer.js";
+export class MethodBuilder {
+    requestAnalyzer = new MethodRequestAnalyzer();
+    responseAnalyzer = new MethodResponseAnalyzer();
+    apiTypeAnalyzer = new MethodApiTypeAnalyzer();
+    bodyAnalyzer = new MethodBodyAnalyzer();
+    build(operation, moduleName) {
+        const name = this.extractName(operation);
+        const description = operation.description ?? operation.summary;
+        const { apiType, attributeType } = this.apiTypeAnalyzer.analyze(operation);
+        this.requestAnalyzer.analyze(operation, moduleName);
+        this.responseAnalyzer.analyze(operation.responses);
+        const bodyType = this.bodyAnalyzer.analyze(operation);
+        const props = this.requestAnalyzer.getProps();
+        const analyzers = {
+            request: {
+                bodyType,
+                responseType: this.responseAnalyzer.responseType,
+                attributeType,
+                apiType,
+                parameters: this.requestAnalyzer.paths,
+                hasEnumResponse: this.responseAnalyzer.hasEnumResponse,
+            },
+            props,
+        };
+        const responseTypeInterface = this.buildResponseTypeInterface(analyzers.request.responseType);
+        return new Method({
+            name,
+            endpoint: operation.endpoint,
+            apiType,
+            attributeType,
+            description,
+            analyzers,
+            responseTypeInterface,
+        });
+    }
+    extractName(operation) {
+        const extracted = operation.operationId?.split("_")[1];
+        if (extracted === "list")
+            return "listAll";
+        return extracted ?? this.apiTypeAnalyzer.analyze(operation).apiType;
+    }
+    buildResponseTypeInterface(responseType) {
+        return responseType ? `${responseType}Interface` : "null";
+    }
+}

package/dist/core/MethodEndpointBuilder.d.ts

@@ -0,0 +1,6 @@
+export declare class MethodEndpointBuilder {
+    build(rawEndpoint: string, paths: {
+        name: string;
+    }[]): string;
+    private processEndpoint;
+}

package/dist/core/MethodEndpointBuilder.js

@@ -0,0 +1,21 @@
+export class MethodEndpointBuilder {
+    build(rawEndpoint, paths) {
+        const processed = this.processEndpoint(rawEndpoint);
+        const a = "`";
+        return `${a}${processed}${a}`;
+    }
+    processEndpoint(rawEndpoint) {
+        return rawEndpoint
+            .split("/")
+            .filter(Boolean)
+            .map((str) => {
+            const match = /^\{(.+)\}$/.exec(str);
+            if (match) {
+                const key = match[1];
+                return `\${${key}}`;
+            }
+            return str;
+        })
+            .join("/");
+    }
+}

package/dist/core/MethodRequestAnalyzer.d.ts

@@ -0,0 +1,16 @@
+import type { ReflectorOperation, AttributeProp } from "../types/types.js";
+import type { PrimitiveProp } from "../props/primitive.property.js";
+export declare class MethodRequestAnalyzer {
+    paths: PrimitiveProp[];
+    headers: PrimitiveProp[];
+    querys: AttributeProp[];
+    cookies: PrimitiveProp[];
+    analyze(operation: ReflectorOperation, moduleName: string): void;
+    private processQueryParam;
+    getProps(): {
+        paths: PrimitiveProp[];
+        headers: PrimitiveProp[];
+        querys: AttributeProp[];
+        cookies: PrimitiveProp[];
+    };
+}

package/dist/core/MethodRequestAnalyzer.js

@@ -0,0 +1,62 @@
+import { PrimitiveProp as PrimitivePropClass } from "../props/primitive.property.js";
+import { ArrayProp as ArrayPropClass } from "../props/array.property.js";
+import { EnumProp as EnumPropClass } from "../props/enum.property.js";
+export class MethodRequestAnalyzer {
+    paths = [];
+    headers = [];
+    querys = [];
+    cookies = [];
+    analyze(operation, moduleName) {
+        if (!operation.parameters || operation.parameters.length === 0)
+            return;
+        for (const object of operation.parameters) {
+            if ("$ref" in object)
+                continue;
+            if (!object.schema)
+                continue;
+            const { required, name, schema, in: inParam } = object;
+            if ("$ref" in schema)
+                continue;
+            const isRequired = !!required;
+            const baseProps = { name, required: isRequired, schemaObject: schema, validator: undefined, isParam: true };
+            if (inParam === "query") {
+                this.processQueryParam(name, schema, moduleName, isRequired);
+            }
+            else if (inParam === "header") {
+                this.headers.push(new PrimitivePropClass(baseProps));
+            }
+            else if (inParam === "path") {
+                this.paths.push(new PrimitivePropClass(baseProps));
+            }
+            else if (inParam === "cookie") {
+                this.cookies.push(new PrimitivePropClass(baseProps));
+            }
+        }
+    }
+    processQueryParam(name, schema, moduleName, isRequired) {
+        if (schema.type === "array") {
+            this.querys.push(new ArrayPropClass({
+                name,
+                schemaObject: schema,
+                schemaName: moduleName,
+                isParam: true,
+                isEnum: false,
+                required: isRequired,
+            }));
+            return;
+        }
+        if (schema.enum) {
+            this.querys.push(new EnumPropClass({ name, required: isRequired, enums: schema.enum, isParam: true, entityName: moduleName }));
+            return;
+        }
+        this.querys.push(new PrimitivePropClass({ name, required: isRequired, schemaObject: schema, validator: undefined, isParam: true }));
+    }
+    getProps() {
+        return {
+            paths: this.paths,
+            headers: this.headers,
+            querys: this.querys,
+            cookies: this.cookies,
+        };
+    }
+}

package/dist/core/MethodResponseAnalyzer.d.ts

@@ -0,0 +1,12 @@
+import type { ResponsesObject } from "../types/open-api-spec.interface.js";
+export declare class MethodResponseAnalyzer {
+    responseType: string | null;
+    hasEnumResponse: boolean;
+    analyze(responses: ResponsesObject): void;
+    private isRef;
+    private componentName;
+    private getFromContent;
+    private typeFromSchemaOrType;
+    private extractEnumType;
+    private typeFromProperties;
+}

package/dist/core/MethodResponseAnalyzer.js

@@ -0,0 +1,96 @@
+export class MethodResponseAnalyzer {
+    responseType = null;
+    hasEnumResponse = false;
+    analyze(responses) {
+        for (const response of Object.values(responses)) {
+            if (!response || this.isRef(response))
+                continue;
+            const schemaOrType = this.getFromContent(response.content);
+            const type = this.typeFromSchemaOrType(schemaOrType);
+            if (type !== undefined) {
+                this.responseType = type;
+                break;
+            }
+        }
+    }
+    isRef(v) {
+        return !!v && typeof v === "object" && "$ref" in v;
+    }
+    componentName(refObj) {
+        const parts = refObj.$ref.split("/");
+        return parts[parts.length - 1];
+    }
+    getFromContent(content) {
+        if (!content || this.isRef(content))
+            return undefined;
+        const first = Object.values(content)[0];
+        const schema = first?.schema;
+        if (!schema)
+            return undefined;
+        if (this.isRef(schema))
+            return this.componentName(schema);
+        return schema;
+    }
+    typeFromSchemaOrType(schemaOrType) {
+        if (!schemaOrType)
+            return undefined;
+        if (typeof schemaOrType === "string") {
+            this.hasEnumResponse = false;
+            return schemaOrType;
+        }
+        const schema = schemaOrType;
+        if (schema.enum) {
+            this.hasEnumResponse = true;
+            return this.extractEnumType(schema);
+        }
+        const allOfFirst = schema.allOf?.[0];
+        if (allOfFirst && !this.isRef(allOfFirst)) {
+            const t = this.typeFromProperties(allOfFirst.properties);
+            if (t !== undefined)
+                return t;
+        }
+        if (schema.type === "array" && schema.items) {
+            const items = schema.items;
+            if (this.isRef(items))
+                return this.componentName(items);
+            if (items.enum) {
+                this.hasEnumResponse = true;
+                return this.extractEnumType(items);
+            }
+            return items.type;
+        }
+        if (schema.properties) {
+            const t = this.typeFromProperties(schema.properties);
+            if (t !== undefined)
+                return t;
+        }
+        return schema.type;
+    }
+    extractEnumType(schema) {
+        const extended = schema;
+        if (extended["x-enum-name"]) {
+            return extended["x-enum-name"];
+        }
+        if (schema.title) {
+            return schema.title;
+        }
+        return "string";
+    }
+    typeFromProperties(properties) {
+        if (!properties?.["data"])
+            return undefined;
+        const data = properties["data"];
+        if (this.isRef(data))
+            return this.componentName(data);
+        if (data.type === "any")
+            return undefined;
+        if (data.enum) {
+            this.hasEnumResponse = true;
+            return this.extractEnumType(data);
+        }
+        if (data.type === "array" && data.items && !this.isRef(data.items) && "enum" in data.items && data.items.enum) {
+            this.hasEnumResponse = true;
+        }
+        return data.type;
+    }
+}

package/dist/core/Module.d.ts

@@ -0,0 +1,16 @@
+import type { Method } from "../method.js";
+import type { Source } from "../file.js";
+export declare class Module {
+    readonly name: string;
+    readonly path: string;
+    readonly moduleName: string;
+    readonly src: Source;
+    readonly methods: Method[];
+    constructor(params: {
+        name: string;
+        path: string;
+        moduleName: string;
+        methods: Method[];
+        src: Source;
+    });
+}

package/dist/core/Module.js

@@ -0,0 +1,14 @@
+export class Module {
+    name;
+    path;
+    moduleName;
+    src;
+    methods;
+    constructor(params) {
+        this.name = params.name;
+        this.path = params.path;
+        this.moduleName = params.moduleName;
+        this.methods = params.methods;
+        this.src = params.src;
+    }
+}

package/dist/core/ModuleBuilder.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentsObject, PathsObject } from "../types/open-api-spec.interface.js";
+import { Module } from "./Module.js";
+export declare class ModuleBuilder {
+    private readonly components;
+    private readonly paths;
+    constructor(params: {
+        components: ComponentsObject;
+        paths: PathsObject;
+    });
+    build(): Module[];
+}

package/dist/core/ModuleBuilder.js

@@ -0,0 +1,45 @@
+import { Source } from "../file.js";
+import { splitByUppercase } from "../utils/StringUtils.js";
+import { getEndpoint } from "../utils/EndpointUtils.js";
+import { Module } from "./Module.js";
+import { Method } from "../method.js";
+export class ModuleBuilder {
+    components;
+    paths;
+    constructor(params) {
+        this.components = params.components;
+        this.paths = params.paths;
+    }
+    build() {
+        const methodsMap = new Map();
+        for (const [path, methods] of Object.entries(this.paths)) {
+            const rawMethod = Object.values(methods)[0];
+            const rawName = rawMethod.operationId?.split("_")[0] ?? "";
+            const teste = splitByUppercase(rawName).filter((x) => x !== "Controller");
+            const moduleName = teste.join("");
+            const baseEndpoint = getEndpoint(path);
+            const operations = Object.entries(methods).map(([apiMethod, attributes]) => ({
+                apiMethod,
+                endpoint: path,
+                ...attributes,
+            }));
+            const existentModule = methodsMap.get(moduleName);
+            if (existentModule) {
+                const newPath = existentModule.path.length > path.length ? path : existentModule.path;
+                methodsMap.set(moduleName, {
+                    ...existentModule,
+                    path: newPath,
+                    operations: [...existentModule.operations, ...operations],
+                });
+            }
+            else {
+                methodsMap.set(moduleName, { operations, path: baseEndpoint, moduleName });
+            }
+        }
+        return Array.from(methodsMap).map(([name, info]) => {
+            const methods = info.operations.map((op) => new Method({ operation: op, moduleName: info.moduleName }));
+            const src = new Source({ path: "" });
+            return new Module({ name, path: info.path, moduleName: info.moduleName, methods, src });
+        });
+    }
+}

package/dist/core/ModuleClassBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { AttributeProp, ParamType } from "../types/types.js";
+import type { ModuleImports } from "./ModuleImports.js";
+export declare class ModuleClassBuilder {
+    private readonly imports;
+    constructor(params: {
+        imports: ModuleImports;
+    });
+    buildClassProps(params: {
+        props: AttributeProp[];
+        name: ParamType;
+    }): string;
+}

package/dist/core/ModuleClassBuilder.js

@@ -0,0 +1,74 @@
+export class ModuleClassBuilder {
+    imports;
+    constructor(params) {
+        this.imports = params.imports;
+    }
+    buildClassProps(params) {
+        const { name, props } = params;
+        const bundle = [];
+        const attributes = [];
+        if (name === "Paths") {
+            props.forEach((prop) => {
+                if ("rawType" in prop) {
+                    attributes.push(prop.patchBuild());
+                }
+            });
+            this.imports.addPageStateImport();
+            return `
+      class ${name} {
+        ${attributes.join(";")}
+      }
+      `;
+        }
+        else if (name === "Querys") {
+            props.forEach((prop) => {
+                if ("rawType" in prop) {
+                    attributes.push(prop.queryBuild());
+                    if ("isEnum" in prop && prop.isEnum) {
+                        this.imports.addReflectorImport("EnumQueryBuilder");
+                        this.imports.addEnumImport(String(prop.type));
+                        bundle.push(`${prop.name}: this.${prop.name}?.values`);
+                    }
+                    else {
+                        bundle.push(prop.bundleBuild());
+                    }
+                }
+                else if ("enumName" in prop) {
+                    this.imports.addEnumImport(prop.enumName);
+                    attributes.push(prop.queryBuild());
+                    bundle.push(prop.bundleBuild());
+                }
+                else {
+                    attributes.push(prop.queryBuild());
+                    this.imports.addEnumImport(prop.type);
+                    bundle.push(prop.queryBundleBuild());
+                    this.imports.addReflectorImport("EnumQueryBuilder");
+                }
+            });
+        }
+        else {
+            props.forEach((prop) => {
+                if ("isEnum" in prop || "enumName" in prop) {
+                    this.imports.addEnumImport(prop.type);
+                }
+                attributes.push(prop.classBuild());
+            });
+        }
+        const bundleBuild = bundle.length > 0
+            ? `
+      bundle() {
+        return {
+          ${bundle.join(",")}
+        }
+      }
+    `
+            : "";
+        return `
+      class ${name} {
+        ${attributes.join(";")}
+
+        ${bundleBuild}
+      }
+    `;
+    }
+}

package/dist/core/ModuleConstructorBuilder.d.ts

@@ -0,0 +1,7 @@
+export interface Form {
+    name: string;
+    type: string;
+}
+export declare class ModuleConstructorBuilder {
+    build(form: Form[]): string;
+}

package/dist/core/ModuleConstructorBuilder.js

@@ -0,0 +1,20 @@
+export class ModuleConstructorBuilder {
+    build(form) {
+        if (form.length === 0)
+            return "";
+        return `
+      constructor(params?: { empty: boolean }) {
+        const isEmpty = PUBLIC_ENVIRONMENT !== 'DEV' || !!params?.empty;
+        this.forms = this.buildForms(isEmpty);
+      }
+
+      private buildForms(isEmpty: boolean) {
+        if(!isEmpty) return this.forms
+
+        return {
+          ${form.map((f) => `${f.name}: new ${f.type}({ empty: true })`).join(",\n          ")}
+        }
+      }
+    `;
+    }
+}