@declaro/core 2.0.0-y.0 → 2.1.1

package/dist/schema/application.d.ts

@@ -1,83 +0,0 @@
-import { Model } from './define-model';
-import { Module } from './module';
-import { DeclaroSchema } from './types';
-import { Response } from './response';
-export type ModuleFactory = (mod: Module) => Module | undefined;
-export declare class Application {
-    private _info;
-    private _modules;
-    private _models;
-    private _responses;
-    constructor(info: DeclaroSchema.InfoObject);
-    /**
-     * Get the application info (read-only). Application info can only be set in the constructor of the application.
-     *
-     * Note: This should be set by the application implementation. It would be dangerous for any one module to be able to change the application info for all of the others.
-     */
-    get info(): import("openapi-types").OpenAPIV3_1.InfoObject;
-    /**
-     * Define a module for the application.
-     *
-     * @param tag The tag info for the module, to be used in the OpenAPI schema
-     * @param factory A convenience function to define the module, adding endpoints, etc.
-     * @returns
-     */
-    defineModule(tag: DeclaroSchema.TagObject, factory?: ModuleFactory): Module;
-    /**
-     * Get a module by name.
-     *
-     * @param name The name of the module to get
-     * @returns The `Module` instance for the given name
-     */
-    getModule(name: string): Module;
-    /**
-     * Add models to the application.
-     *
-     * @param models The models to add to the application
-     * @example app.addModel(User)
-     * @example app.addModel(User, Post)
-     * @example app.addModel(...myModels)
-     * @returns The application instance
-     */
-    addModel(...models: Model[]): this;
-    /**
-     * Get a model by name.
-     *
-     * @param name The name of the model to get
-     * @returns The `Model` instance for the given name
-     */
-    getModel(name: string): Model;
-    /**
-     * Get all models.
-     *
-     * @returns All models in the application
-     */
-    getModels(): Model[];
-    /**
-     * Add a response to the application.
-     *
-     * @param code The HTTP status code for the response
-     * @param response The response object
-     * @returns The application instance
-     */
-    addResponse(...responses: Response[]): this;
-    /**
-     * Get a response by status code.
-     *
-     * @param code The HTTP status code for the response
-     * @returns The `Response` instance for the given status code
-     */
-    getResponse(code: number): Response;
-    /**
-     * Get all responses. (read-only)
-     *
-     * @returns All responses in the application
-     */
-    get responses(): Map<number, Response>;
-    /**
-     * Get all responses as a hash of keys and values.
-     *
-     * @returns A hash of keys and values representing all responses in the application
-     */
-    getResponseSchema(): DeclaroSchema.ResponsesObject;
-}

package/dist/schema/application.test.d.ts

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

package/dist/schema/define-model.d.ts

@@ -1,10 +0,0 @@
-import { DeclaroSchema } from './types';
-export type Model<T extends DeclaroSchema.AnyObjectProperties = DeclaroSchema.AnyObjectProperties, N extends Readonly<string> = string> = {
-    name: N;
-    schema: DeclaroSchema.SchemaObject<T>;
-    isModel: true;
-};
-export type ModelName<T extends Model<any, string>> = T['name'];
-export type ModelProperties<T extends Model<any, string>> = T['schema']['properties'];
-export declare function initializeModel(schema: DeclaroSchema.SchemaObject<any>): DeclaroSchema.SchemaObject<any, string>;
-export declare function defineModel<T extends DeclaroSchema.AnyObjectProperties, N extends Readonly<string>>(name: N, doc: DeclaroSchema.SchemaObject<T>): Model<T, N>;

package/dist/schema/define-model.test.d.ts

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

package/dist/schema/formats.d.ts

@@ -1,10 +0,0 @@
-export declare enum RelationFormat {
-    OneToOne = "one-to-one",
-    OneToMany = "one-to-many",
-    ManyToOne = "many-to-one",
-    ManyToMany = "many-to-many",
-    EmbeddedObject = "embedded-object",
-    EmbeddedArray = "embedded-array"
-}
-export type RelationReferenceType = 'object' | 'array';
-export declare function getReferenceType(format: string): RelationReferenceType;

package/dist/schema/index.d.ts

@@ -1,10 +0,0 @@
-export * from './define-model';
-export * from './supported-types';
-export * from './transform-model';
-export * from './labels';
-export * from './module';
-export * from './application';
-export * from './response';
-export * from './formats';
-export * from './properties';
-export * from './types';

package/dist/schema/labels.d.ts

@@ -1,13 +0,0 @@
-export type EntityLabels = {
-    singularLabel?: string;
-    pluralLabel?: string;
-    singularParameter?: string;
-    pluralParameter?: string;
-    singularSlug?: string;
-    pluralSlug?: string;
-    singularEntityName?: string;
-    pluralEntityName?: string;
-    singularTableName?: string;
-    pluralTableName?: string;
-};
-export declare function getEntityLabels(entity: string, labels?: Partial<EntityLabels>): EntityLabels;

package/dist/schema/labels.test.d.ts

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

package/dist/schema/module.d.ts

@@ -1,7 +0,0 @@
-import { Application } from './application';
-import { DeclaroSchema } from './types';
-export declare class Module {
-    readonly application: Application;
-    readonly tag: DeclaroSchema.TagObject;
-    constructor(application: Application, tag: DeclaroSchema.TagObject);
-}

package/dist/schema/module.test.d.ts

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

package/dist/schema/properties.d.ts

@@ -1,19 +0,0 @@
-import { DeclaroSchema } from './types';
-export declare const t: {
-    string: <T extends DeclaroSchema.NonArraySchemaObject<any, any>>(property?: T) => T & {
-        type: "string";
-    };
-    number: <T extends DeclaroSchema.NonArraySchemaObject<any, any>>(property?: T) => T & {
-        type: "number";
-    };
-    boolean: <T extends DeclaroSchema.NonArraySchemaObject<any, any>>(property?: T) => T & {
-        type: "boolean";
-    };
-    integer: <T extends DeclaroSchema.NonArraySchemaObject<any, any>>(property?: T) => T & {
-        type: "integer";
-    };
-    object: <T extends DeclaroSchema.NonArraySchemaObject<any, any>>(property?: T) => T & {
-        type: "object";
-    };
-    array: <T extends DeclaroSchema.NonArraySchemaObject<any, any>>(property?: T) => never;
-};

package/dist/schema/response.d.ts

@@ -1,31 +0,0 @@
-import { DeclaroSchema } from './types';
-export type MediaRecord<T extends DeclaroSchema.AnyObjectProperties> = {
-    contentType: string;
-    media: DeclaroSchema.MediaTypeObject<T>;
-};
-export declare class Response {
-    private _code;
-    private _response;
-    private _mediaTypes;
-    constructor(code: number, response: DeclaroSchema.ResponseObject);
-    /**
-     *
-     * @param contentType The HTTP content type
-     * @param media The openapi media schema defining the response type.
-     * @returns An instance of the response object for chaining content types.
-     */
-    content(contentType: string, ...media: DeclaroSchema.MediaTypeObject<any>[]): this;
-    merge(response: Response): this;
-    /**
-     * The response code.
-     *
-     * Note: Read-only. This can only be initialized in the constructor.
-     */
-    get code(): number;
-    /**
-     * The fully composed openapi response object.
-     */
-    get schema(): DeclaroSchema.ResponseObject;
-    protected getContentTypes(): string[];
-    protected getMediaForContentType(contentType: string): DeclaroSchema.MediaTypeObject<any>[];
-}

package/dist/schema/response.test.d.ts

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

package/dist/schema/supported-types.d.ts

@@ -1,12 +0,0 @@
-export declare const TypescriptMap: {
-    string: string;
-    text: string;
-    integer: string;
-    number: string;
-    float: string;
-    double: string;
-    boolean: string;
-    date: string;
-    datetime: string;
-    time: string;
-};

package/dist/schema/supported-types.test.d.ts

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

package/dist/schema/transform-model.d.ts

@@ -1,4 +0,0 @@
-import { Model } from '.';
-export declare function transformModel(model: Model<any>): {
-    toTypescript(): string;
-};

package/dist/schema/transform-model.test.d.ts

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

package/dist/schema/types.d.ts

@@ -1,95 +0,0 @@
-import { OpenAPIV3_1 } from 'openapi-types';
-import { ModelNames } from '$models/reference';
-import { EntityLabels } from './labels';
-export declare namespace DeclaroSchema {
-    type Modify<T, R> = Omit<T, keyof R> & R;
-    type NonArraySchemaObjectType = OpenAPIV3_1.NonArraySchemaObjectType;
-    type ArraySchemaObjectType = OpenAPIV3_1.ArraySchemaObjectType;
-    type AnySchemaObjectType = NonArraySchemaObjectType | ArraySchemaObjectType;
-    type AnyObjectProperties = {
-        [name: string]: SchemaObject<any> | ReferenceObject;
-    };
-    type AnyObjectParameters = {
-        [name: string]: Omit<DeclaroSchema.ParameterObject, 'name'>;
-    };
-    interface BaseSchemaObject<T extends AnyObjectProperties, N extends ModelNames = ModelNames> extends OpenAPIV3_1.BaseSchemaObject {
-        $schema?: N;
-        propertyName?: string;
-        additionalProperties?: boolean | ReferenceObject | SchemaObject<T>;
-        properties?: T;
-        labels?: EntityLabels;
-        not?: ReferenceObject | SchemaObject<T>;
-        allOf?: (ReferenceObject | SchemaObject<T>)[];
-        anyOf?: (ReferenceObject | SchemaObject<T>)[];
-        oneOf?: (ReferenceObject | SchemaObject<T>)[];
-    }
-    interface NonArraySchemaObject<T extends AnyObjectProperties, N extends ModelNames> extends BaseSchemaObject<T, N> {
-        type?: NonArraySchemaObjectType;
-        labels?: EntityLabels;
-    }
-    interface ArraySchemaObject<T extends AnyObjectProperties, N extends ModelNames> extends BaseSchemaObject<T> {
-        type: ArraySchemaObjectType;
-        items: ReferenceObject | SchemaObject<T, N>;
-    }
-    type SchemaObject<T extends AnyObjectProperties, N extends string = string> = ArraySchemaObject<T, N> | NonArraySchemaObject<T, N>;
-    type PropertyType<T extends SchemaObject<any>> = T['type'] extends 'string' ? string : T['type'] extends 'boolean' ? boolean : T['type'] extends 'number' ? number : T['type'] extends 'integer' ? number : T['type'] extends 'object' ? ObjectPayload<T['properties']> : T['type'] extends 'array' ? ObjectPayload<T['properties']>[] : any;
-    type OperationInput<T extends AnyObjectParameters> = {
-        [K in keyof T]: PropertyType<T[K]['schema']>;
-    };
-    type ObjectPayload<T extends AnyObjectProperties> = {
-        [K in keyof T]: PropertyType<T[K]>;
-    };
-    type Payload<T extends AnyObjectProperties, TSchema extends SchemaObject<T>> = any;
-    interface ReferenceObject {
-        $ref: ModelNames;
-        format?: string;
-    }
-    type InfoObject = OpenAPIV3_1.InfoObject;
-    type TagObject = OpenAPIV3_1.TagObject;
-    type ExampleObject = OpenAPIV3_1.ExampleObject;
-    type MediaTypeObject<T extends AnyObjectProperties> = Modify<OpenAPIV3_1.MediaTypeObject, {
-        schema?: SchemaObject<T> | ReferenceObject;
-        examples?: Record<string, ReferenceObject | ExampleObject>;
-    }>;
-    type ServerObject = OpenAPIV3_1.ServerObject;
-    type LinkObject = Modify<OpenAPIV3_1.LinkObject, {
-        server?: ServerObject;
-    }>;
-    type ResponseObject = Modify<OpenAPIV3_1.ResponseObject, {
-        headers?: {
-            [header: string]: ReferenceObject | HeaderObject;
-        };
-        content?: {
-            [media: string]: MediaTypeObject<any>;
-        };
-        links?: {
-            [link: string]: ReferenceObject | LinkObject;
-        };
-    }>;
-    type ResponsesObject = OpenAPIV3_1.ResponsesObject;
-    type HeaderObject = OpenAPIV3_1.HeaderObject;
-    type HttpMethods = OpenAPIV3_1.HttpMethods;
-    type ParameterObject = Modify<OpenAPIV3_1.ParameterObject, {
-        in: 'query' | 'header' | 'path' | 'cookie';
-        schema?: SchemaObject<any> | ReferenceObject;
-    }>;
-    type RequestBodyObject<T extends AnyObjectProperties> = Modify<OpenAPIV3_1.RequestBodyObject, {
-        content: {
-            [media: string]: MediaTypeObject<T>;
-        };
-    }>;
-    type CallbackObject = Record<string, PathItemObject | ReferenceObject>;
-    type PathItemObject<T extends {} = {}> = Modify<OpenAPIV3_1.PathItemObject<T>, {
-        servers?: ServerObject[];
-        parameters?: (ReferenceObject | ParameterObject)[];
-    }> & {
-        [method in HttpMethods]?: OperationObject<T>;
-    };
-    type OperationObject<T extends {} = {}> = Modify<OpenAPIV3_1.OperationObject<T>, {
-        parameters?: ParameterObject[];
-        requestBody?: ReferenceObject | RequestBodyObject<T>;
-        responses?: ResponsesObject;
-        callbacks?: Record<string, ReferenceObject | CallbackObject>;
-        servers?: ServerObject[];
-    }> & T;
-}

package/dist/schema/types.test.d.ts

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

package/dist/typescript/fetch.d.ts

@@ -1,2 +0,0 @@
-import { default as fetch } from 'node-fetch';
-export type FetchFunc = typeof fetch;

package/dist/typescript/objects.d.ts

@@ -1,12 +0,0 @@
-export type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
-declare const _default: {};
-export default _default;
-export type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-/**
- * Merge two object types without using an intersection type. Intersection types preserve the original types of the objects causing confusion, while this type will merge the types of the objects.
- */
-export type Merge<A, B> = {
-    [key in keyof A | keyof B]: key extends keyof B ? B[key] : key extends keyof A ? A[key] : never;
-};

package/dist/validation/validator.test.d.ts

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

package/src/helpers/index.ts

@@ -1 +0,0 @@
-export * from './ucfirst'

package/src/helpers/ucfirst.ts

@@ -1,3 +0,0 @@
-export function ucfirst(s) {
-    return s.substring(0, 1).toUpperCase() + s.substring(1);
-}

package/src/schema/application.test.ts

@@ -1,286 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { Application } from './application'
-import { Module } from './module'
-import { defineModel } from './define-model'
-import type { OpenAPIV3_1 } from 'openapi-types'
-import { Response } from './response'
-
-describe('Application schema', () => {
-    it('should define an application schema', () => {
-        const app = new Application({
-            title: 'My API',
-            version: '1.0.0',
-            description: 'My API description',
-            termsOfService: 'https://example.com/terms',
-            contact: {
-                name: 'API Support',
-                url: 'https://example.com/support',
-                email: 'test@test.com',
-            },
-        })
-
-        expect(app.info.title).toBe('My API')
-        expect(app.info.version).toBe('1.0.0')
-        expect(app.info.description).toBe('My API description')
-        expect(app.info.termsOfService).toBe('https://example.com/terms')
-        expect(app.info.contact.name).toBe('API Support')
-        expect(app.info.contact.url).toBe('https://example.com/support')
-        expect(app.info.contact.email).toBe('test@test.com')
-    })
-
-    it('should be able to add a module', () => {
-        const app = new Application({
-            title: 'My API',
-            version: '1.0.0',
-            description: 'My API description',
-            termsOfService: 'https://example.com/terms',
-            contact: {
-                name: 'API Support',
-                url: 'https://example.com/support',
-                email: 'test@test.com',
-            },
-        })
-
-        const result = app.defineModule({
-            name: 'Module',
-            description: 'Module description',
-            externalDocs: {
-                description: 'External documentation',
-                url: 'https://example.com/docs',
-            },
-        })
-
-        expect(result).toBeInstanceOf(Module)
-
-        const module = app.getModule('Module')
-
-        expect(module).toBeInstanceOf(Module)
-
-        expect(module.application).toBeInstanceOf(Application)
-        expect(module.application.info.title).toBe('My API')
-        expect(module.application.info.version).toBe('1.0.0')
-
-        expect(module).toBeInstanceOf(Module)
-        expect(module.tag.name).toBe('Module')
-        expect(module.tag.description).toBe('Module description')
-        expect(module.tag.externalDocs.description).toBe('External documentation')
-    })
-
-    it('Should allow multiple module definitions to be chained', () => {
-        const app = new Application({
-            title: 'My API',
-            version: '1.0.0',
-            description: 'My API description',
-            termsOfService: 'https://example.com/terms',
-            contact: {
-                name: 'API Support',
-                url: 'https://example.com/support',
-                email: 'test@test.com',
-            },
-        })
-
-        app.defineModule({
-            name: 'Module1',
-            description: 'Module 1 description',
-            externalDocs: {
-                description: 'External documentation 1',
-                url: 'https://example.com/docs1',
-            },
-        })
-        app.defineModule({
-            name: 'Module2',
-            description: 'Module 2 description',
-            externalDocs: {
-                description: 'External documentation 2',
-                url: 'https://example.com/docs2',
-            },
-        })
-
-        const module1 = app.getModule('Module1')
-        const module2 = app.getModule('Module2')
-
-        expect(module1.tag.name).toBe('Module1')
-        expect(module1.tag.description).toBe('Module 1 description')
-        expect(module1.tag.externalDocs.description).toBe('External documentation 1')
-        expect(module1.tag.externalDocs.url).toBe('https://example.com/docs1')
-
-        expect(module2.tag.name).toBe('Module2')
-        expect(module2.tag.description).toBe('Module 2 description')
-        expect(module2.tag.externalDocs.description).toBe('External documentation 2')
-        expect(module2.tag.externalDocs.url).toBe('https://example.com/docs2')
-    })
-
-    it('Should allow models to be added to the application', () => {
-        const app = new Application({
-            title: 'My API',
-            version: '1.0.0',
-            description: 'My API description',
-            termsOfService: 'https://example.com/terms',
-            contact: {
-                name: 'API Support',
-                url: 'https://example.com/support',
-                email: 'test@test.com',
-            },
-        })
-
-        const model1 = defineModel('Model1', {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                },
-            },
-        })
-
-        const model2 = defineModel('Model2', {
-            type: 'object',
-            properties: {
-                number: {
-                    type: 'integer',
-                },
-            },
-        })
-
-        app.addModel(model1, model2)
-
-        const allModels = app.getModels()
-
-        expect(allModels).toHaveLength(2)
-
-        expect(allModels[0].name).toBe('Model1')
-        expect(allModels[1].name).toBe('Model2')
-    })
-
-    it('Should allow responses to be added to the application', () => {
-        const app = new Application({
-            title: 'My API',
-            version: '1.0.0',
-            description: 'My API description',
-            termsOfService: 'https://example.com/terms',
-            contact: {
-                name: 'API Support',
-                url: 'https://example.com/support',
-                email: 'test@test.com',
-            },
-        })
-
-        const error500 = new Response(500, {
-            description: 'Internal server error',
-        }).content('application/json', {
-            schema: {
-                type: 'object',
-                properties: {
-                    message: {
-                        type: 'string',
-                    },
-                },
-            },
-        })
-
-        const error404 = new Response(404, {
-            description: 'Not found',
-        }).content('application/json', {
-            schema: {
-                type: 'object',
-                properties: {
-                    message: {
-                        type: 'string',
-                    },
-                },
-            },
-        })
-
-        const error400 = new Response(400, {
-            description: 'Bad request',
-        }).content('application/json', {
-            schema: {
-                type: 'object',
-                properties: {
-                    message: {
-                        type: 'string',
-                    },
-                },
-            },
-        })
-
-        app.addResponse(error500, error404, error400)
-
-        const response500 = app.getResponse(500)
-        const response404 = app.getResponse(404)
-        const response400 = app.getResponse(400)
-
-        const allResponses = app.getResponseSchema()
-
-        expect(response500.code).toBe(500)
-        expect(response500.schema.description).toBe('Internal server error')
-
-        expect(response404.code).toBe(404)
-        expect(response404.schema.description).toBe('Not found')
-
-        expect(response400.code).toBe(400)
-        expect(response400.schema.description).toBe('Bad request')
-
-        expect(allResponses[500].description).toBe('Internal server error')
-        expect((allResponses[500] as any).content['application/json'].schema.type).toBe('object')
-        expect((allResponses[500] as any).content['application/json'].schema.properties.message.type).toBe('string')
-
-        expect(allResponses[404].description).toBe('Not found')
-        expect((allResponses[404] as any).content['application/json'].schema.type).toBe('object')
-        expect((allResponses[404] as any).content['application/json'].schema.properties.message.type).toBe('string')
-
-        expect(allResponses[400].description).toBe('Bad request')
-        expect((allResponses[400] as any).content['application/json'].schema.type).toBe('object')
-        expect((allResponses[400] as any).content['application/json'].schema.properties.message.type).toBe('string')
-    })
-
-    it('Should allow paths to be added to the application', () => {
-        function test(doc: OpenAPIV3_1.Document) {}
-
-        test({
-            openapi: '3.0.0',
-            info: {
-                title: 'My API',
-                version: '1.0.0',
-            },
-            paths: {
-                '/test': {
-                    get: {
-                        description: 'Test endpoint',
-                        responses: {
-                            200: {
-                                description: 'Successful response',
-                                content: {
-                                    'application/json': {
-                                        schema: {
-                                            oneOf: [
-                                                {
-                                                    type: 'object',
-                                                    properties: {
-                                                        message: {
-                                                            type: 'string',
-                                                        },
-                                                    },
-                                                },
-                                                {
-                                                    type: 'object',
-                                                    properties: {
-                                                        error: {
-                                                            type: 'string',
-                                                        },
-                                                    },
-                                                },
-                                            ],
-                                        },
-                                    },
-                                },
-                            },
-                            500: {
-                                description: 'Internal server error',
-                            },
-                        },
-                    },
-                },
-            },
-        })
-    })
-})