manifest 4.10.1 → 4.11.0

package/dist/common/src/Helpers.d.ts

@@ -0,0 +1,16 @@
+import { ImageSizesObject, RelationshipManifest } from '@repo/types';
+export declare function getRecordKeyByValue<T extends Record<string, string>, V extends T[keyof T]>(record: T, value: V): string | undefined;
+export declare function camelize(str: string | string[]): string;
+export declare function kebabize(str: string): string;
+export declare function lowerCaseFirstLetter(str: string): string;
+export declare function upperCaseFirstLetter(str: string): string;
+export declare function getRandomIntExcluding({ min, max, exclude }: {
+    min: number;
+    max: number;
+    exclude?: number[];
+}): number;
+export declare function getDtoPropertyNameFromRelationship(relationship: RelationshipManifest): string;
+export declare function getRelationshipNameFromDtoPropertyName(propertyName: string): string;
+export declare function forceNumberArray(value: string | number | number[] | string[]): number[];
+export declare function getSmallestImageSize(imageSizesObject: ImageSizesObject): string;
+export declare function base64ToBlob(base64: string, contentType: string): Blob;

package/dist/common/src/base-classes/BaseSdk.d.ts

@@ -0,0 +1,14 @@
+export declare class BaseSDK {
+    slug: string;
+    isSingleEntity: boolean;
+    queryParams: {
+        [key: string]: string;
+    };
+    from(slug: string): this;
+    where(whereClause: string): this;
+    andWhere(whereClause: string): this;
+    orderBy(propName: string, order?: {
+        desc: boolean;
+    }): this;
+    with(relations: string[]): this;
+}

package/dist/common/src/base-classes/index.d.ts

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

package/dist/common/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Helpers';
+export * from './base-classes';

package/dist/json-schema/src/index.d.ts

@@ -0,0 +1,98 @@
+declare const _default: ({
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    properties: {};
+} | {
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    anyOf: ({
+        type: string;
+        properties: {
+            name: {
+                description: string;
+                type: string;
+            };
+            type: {
+                description: string;
+                type: string;
+                enum: string[];
+            };
+            validation: {
+                description: string;
+                $ref: string;
+            };
+            default: {
+                description: string;
+                type: string[];
+            };
+            hidden: {
+                description: string;
+                type: string;
+            };
+            options: {
+                allOf: {
+                    $ref: string;
+                }[];
+                oneOf: {
+                    if: {
+                        type: string;
+                        properties: {
+                            type: {
+                                const: string;
+                            };
+                        };
+                    };
+                    then: {
+                        $ref: string;
+                    };
+                }[];
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+        description?: undefined;
+    } | {
+        type: string;
+        description: string;
+        properties?: undefined;
+        required?: undefined;
+        additionalProperties?: undefined;
+    })[];
+} | {
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    anyOf: ({
+        type: string;
+        properties: {
+            name: {
+                type: string;
+                description: string;
+            };
+            entity: {
+                type: string;
+                description: string;
+            };
+            eager: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+        description?: undefined;
+    } | {
+        type: string;
+        description: string;
+        properties?: undefined;
+        required?: undefined;
+        additionalProperties?: undefined;
+    })[];
+})[];
+export default _default;

package/dist/manifest/src/app.module.d.ts

@@ -0,0 +1,7 @@
+import { LoggerService } from './logger/logger.service';
+export declare class AppModule {
+    private loggerService;
+    constructor(loggerService: LoggerService);
+    onModuleInit(): Promise<void>;
+    private init;
+}

package/dist/manifest/src/app.module.js

@@ -68,16 +68,24 @@ exports.AppModule = AppModule = __decorate([
             typeorm_1.TypeOrmModule.forRootAsync({
                 imports: [config_1.ConfigModule, entity_module_1.EntityModule, manifest_module_1.ManifestModule],
                 useFactory: async (configService, entityLoaderService, manifestService) => {
-                    const isPostgres = configService.get('DB_CONNECTION') === 'postgres';
+                    let dbConnection;
                     let databaseConfig;
-                    if (isPostgres) {
-                        databaseConfig = configService.get('database').postgres;
-                    }
-                    else {
-                        databaseConfig = configService.get('database').sqlite;
+                    switch (configService.get('DB_CONNECTION')) {
+                        case 'postgres':
+                            dbConnection = 'postgres';
+                            databaseConfig = configService.get('database').postgres;
+                            break;
+                        case 'mysql':
+                            dbConnection = 'mysql';
+                            databaseConfig = configService.get('database').mysql;
+                            break;
+                        default:
+                            dbConnection = 'sqlite';
+                            databaseConfig = configService.get('database').sqlite;
+                            break;
                     }
                     await manifestService.loadManifest(configService.get('paths').manifestFile);
-                    const entities = entityLoaderService.loadEntities(isPostgres);
+                    const entities = entityLoaderService.loadEntities(dbConnection);
                     return Object.assign(databaseConfig, { entities });
                 },
                 inject: [config_1.ConfigService, entity_loader_service_1.EntityLoaderService, manifest_service_1.ManifestService]

package/dist/manifest/src/auth/auth.controller.d.ts

@@ -0,0 +1,21 @@
+import { AuthenticableEntity } from '@repo/types';
+import { Request } from 'express';
+import { AuthService } from './auth.service';
+import { SignupAuthenticableEntityDto } from './dtos/signup-authenticable-entity.dto';
+export declare class AuthController {
+    private readonly authService;
+    constructor(authService: AuthService);
+    getToken(entity: string, signupUserDto: SignupAuthenticableEntityDto): Promise<{
+        token: string;
+    }>;
+    signupAdmin(signupUserDto: SignupAuthenticableEntityDto): Promise<{
+        token: string;
+    }>;
+    signup(entity: string, signupUserDto: SignupAuthenticableEntityDto): Promise<{
+        token: string;
+    }>;
+    getCurrentUser(_entity: string, req: Request): Promise<AuthenticableEntity>;
+    isDefaultAdminExists(): Promise<{
+        exists: boolean;
+    }>;
+}

package/dist/manifest/src/auth/auth.module.d.ts

@@ -0,0 +1,2 @@
+export declare class AuthModule {
+}

package/dist/manifest/src/auth/auth.service.d.ts

@@ -0,0 +1,31 @@
+import { AuthenticableEntity } from '@repo/types';
+import { ConfigService } from '@nestjs/config';
+import { Request } from 'express';
+import { EntityService } from '../entity/services/entity.service';
+import { SignupAuthenticableEntityDto } from './dtos/signup-authenticable-entity.dto';
+import { EntityManifestService } from '../manifest/services/entity-manifest.service';
+export declare class AuthService {
+    private readonly configService;
+    private readonly entityService;
+    private readonly entityManifestService;
+    constructor(configService: ConfigService, entityService: EntityService, entityManifestService: EntityManifestService);
+    createToken(entitySlug: string, signupUserDto: SignupAuthenticableEntityDto): Promise<{
+        token: string;
+    }>;
+    signup(entitySlug: string, signupUserDto: SignupAuthenticableEntityDto, byPassAdminCheck?: boolean): Promise<{
+        token: string;
+    }>;
+    getUserFromToken(token: string): Promise<{
+        user: AuthenticableEntity;
+        entitySlug: string;
+    }>;
+    getUserFromRequest(req: Request): Promise<{
+        user: AuthenticableEntity;
+        entitySlug: string;
+    }>;
+    isReqUserAdmin(req: Request): Promise<boolean>;
+    isDefaultAdminExists(): Promise<{
+        exists: boolean;
+    }>;
+    findUserFromCredentials(entitySlug: string, email: string, password: string): Promise<AuthenticableEntity>;
+}

package/dist/manifest/src/auth/dtos/signup-authenticable-entity.dto.d.ts

@@ -0,0 +1,4 @@
+export declare class SignupAuthenticableEntityDto {
+    email: string;
+    password: string;
+}

package/dist/manifest/src/auth/guards/is-admin.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { AuthService } from '../auth.service';
+export declare class IsAdminGuard implements CanActivate {
+    private readonly authService;
+    constructor(authService: AuthService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/manifest/src/auth/guards/is-db-empty.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate } from '@nestjs/common';
+import { DatabaseService } from '../../crud/services/database.service';
+export declare class IsDbEmptyGuard implements CanActivate {
+    private readonly databaseService;
+    constructor(databaseService: DatabaseService);
+    canActivate(): Promise<boolean>;
+}

package/dist/manifest/src/config/database.d.ts

@@ -0,0 +1,11 @@
+import { MysqlConnectionOptions } from 'typeorm/driver/mysql/MysqlConnectionOptions';
+import { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions';
+import { SqliteConnectionOptions } from 'typeorm/driver/sqlite/SqliteConnectionOptions';
+declare const _default: () => {
+    database: {
+        sqlite: SqliteConnectionOptions;
+        postgres: PostgresConnectionOptions;
+        mysql: MysqlConnectionOptions;
+    };
+};
+export default _default;

package/dist/manifest/src/config/database.js

@@ -3,28 +3,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = () => {
     return {
         database: {
-            sqlite: {
-                type: 'sqlite',
-                database: process.env.DB_PATH || `${process.cwd()}/manifest/backend.db`,
-                dropSchema: process.env.DB_DROP_SCHEMA === 'true' || false,
-                synchronize: true
-            },
-            postgres: {
-                type: 'postgres',
-                host: process.env.DB_HOST || 'localhost',
-                port: parseInt(process.env.DB_PORT, 10) || 5432,
-                username: process.env.DB_USERNAME || 'postgres',
-                password: process.env.DB_PASSWORD || 'postgres',
-                database: process.env.DB_DATABASE || 'manifest',
-                dropSchema: process.env.DB_DROP_SCHEMA === 'true' || false,
-                ssl: process.env.DB_SSL === 'true'
-                    ? {
-                        rejectUnauthorized: false,
-                        requestCert: true
-                    }
-                    : false,
-                synchronize: true
-            }
+            sqlite: getSqliteConnectionOptions(),
+            postgres: getPostgresConnectionOptions(),
+            mysql: getMysqlConnectionOptions()
         }
     };
 };
+function getSqliteConnectionOptions() {
+    return {
+        type: 'sqlite',
+        database: process.env.DB_PATH || `${process.cwd()}/manifest/backend.db`,
+        dropSchema: process.env.DB_DROP_SCHEMA === 'true' || false,
+        synchronize: true
+    };
+}
+function getPostgresConnectionOptions() {
+    return {
+        type: 'postgres',
+        host: process.env.DB_HOST || 'localhost',
+        port: parseInt(process.env.DB_PORT, 10) || 5432,
+        username: process.env.DB_USERNAME || 'postgres',
+        password: process.env.DB_PASSWORD || 'postgres',
+        database: process.env.DB_DATABASE || 'manifest',
+        dropSchema: process.env.DB_DROP_SCHEMA === 'true' || false,
+        ssl: process.env.DB_SSL === 'true'
+            ? {
+                rejectUnauthorized: false,
+                requestCert: true
+            }
+            : false,
+        synchronize: true
+    };
+}
+function getMysqlConnectionOptions() {
+    return {
+        type: 'mysql',
+        host: process.env.DB_HOST || 'localhost',
+        port: parseInt(process.env.DB_PORT, 10) || 3306,
+        username: process.env.DB_USERNAME || 'root',
+        password: process.env.DB_PASSWORD || 'password',
+        database: process.env.DB_DATABASE || 'manifest',
+        dropSchema: process.env.DB_DROP_SCHEMA === 'true' || false,
+        ssl: process.env.DB_SSL === 'true'
+            ? {
+                rejectUnauthorized: false,
+                requestCert: true
+            }
+            : false,
+        synchronize: true
+    };
+}

package/dist/manifest/src/config/general.d.ts

@@ -0,0 +1,8 @@
+declare const _default: () => {
+    port: number | string;
+    nodeEnv: string;
+    tokenSecretKey: string;
+    baseUrl: string;
+    showOpenApiDocs: boolean;
+};
+export default _default;

package/dist/manifest/src/config/paths.d.ts

@@ -0,0 +1,9 @@
+declare const _default: () => {
+    paths: {
+        adminPanelFolder: string;
+        publicFolder: string;
+        manifestFile: string;
+        handlersFolder: string;
+    };
+};
+export default _default;

package/dist/manifest/src/config/storage.d.ts

@@ -0,0 +1,10 @@
+declare const _default: () => {
+    storage: {
+        s3Bucket: string;
+        s3Endpoint: string;
+        s3Region: string;
+        s3AccessKeyId: string;
+        s3SecretAccessKey: string;
+    };
+};
+export default _default;

package/dist/manifest/src/constants.d.ts

@@ -0,0 +1,25 @@
+import { EntityManifest, PropertyManifest, ImageSizesObject, PolicyManifest } from '@repo/types';
+export declare const STORAGE_PATH: string;
+export declare const API_PATH: string;
+export declare const COLLECTIONS_PATH: string;
+export declare const SINGLES_PATH: string;
+export declare const ENDPOINTS_PATH: string;
+export declare const DEFAULT_PORT: number;
+export declare const DEFAULT_RESULTS_PER_PAGE: number;
+export declare const SALT_ROUNDS: number;
+export declare const DEFAULT_SEED_COUNT: number;
+export declare const DEFAULT_MAX_MANY_TO_MANY_RELATIONS: number;
+export declare const DUMMY_FILE_NAME: string;
+export declare const DUMMY_IMAGE_NAME: string;
+export declare const DEFAULT_TOKEN_SECRET_KEY: string;
+export declare const DEFAULT_IMAGE_SIZES: ImageSizesObject;
+export declare const AUTHENTICABLE_PROPS: PropertyManifest[];
+export declare const DEFAULT_ADMIN_CREDENTIALS: {
+    email: string;
+    password: string;
+};
+export declare const ADMIN_ENTITY_MANIFEST: EntityManifest;
+export declare const QUERY_PARAMS_RESERVED_WORDS: string[];
+export declare const ADMIN_ACCESS_POLICY: PolicyManifest;
+export declare const PUBLIC_ACCESS_POLICY: PolicyManifest;
+export declare const FORBIDDEN_ACCESS_POLICY: PolicyManifest;

package/dist/manifest/src/crud/controllers/collection.controller.d.ts

@@ -0,0 +1,22 @@
+import { BaseEntity, Paginator, SelectOption } from '@repo/types';
+import { CrudService } from '../services/crud.service';
+import { AuthService } from '../../auth/auth.service';
+import { Request } from 'express';
+export declare class CollectionController {
+    private readonly crudService;
+    private readonly authService;
+    constructor(crudService: CrudService, authService: AuthService);
+    findAll(entitySlug: string, queryParams: {
+        [key: string]: string | string[];
+    }, req: Request): Promise<Paginator<BaseEntity>>;
+    findSelectOptions(entitySlug: string, queryParams: {
+        [key: string]: string | string[];
+    }): Promise<SelectOption[]>;
+    findOne(entitySlug: string, id: number, queryParams: {
+        [key: string]: string | string[];
+    }, req: Request): Promise<BaseEntity>;
+    store(entity: string, entityDto: Partial<BaseEntity>): Promise<BaseEntity>;
+    put(entitySlug: string, id: number, itemDto: Partial<BaseEntity>): Promise<BaseEntity>;
+    patch(entitySlug: string, id: number, itemDto: Partial<BaseEntity>): Promise<BaseEntity>;
+    delete(entity: string, id: number): Promise<BaseEntity>;
+}

package/dist/manifest/src/crud/controllers/database.controller.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseService } from '../services/database.service';
+export declare class DatabaseController {
+    private readonly databaseService;
+    constructor(databaseService: DatabaseService);
+    isDbEmpty(): Promise<{
+        empty: boolean;
+    }>;
+}

package/dist/manifest/src/crud/controllers/single.controller.d.ts

@@ -0,0 +1,12 @@
+import { AuthService } from '../../auth/auth.service';
+import { Request } from 'express';
+import { CrudService } from '../services/crud.service';
+import { BaseEntity } from '@repo/types';
+export declare class SingleController {
+    private readonly authService;
+    private readonly crudService;
+    constructor(authService: AuthService, crudService: CrudService);
+    findOne(entitySlug: string, req: Request): Promise<BaseEntity>;
+    put(entitySlug: string, itemDto: Partial<BaseEntity>): Promise<BaseEntity>;
+    patch(entitySlug: string, itemDto: Partial<BaseEntity>): Promise<BaseEntity>;
+}

package/dist/manifest/src/crud/crud.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CrudModule {
+}

package/dist/manifest/src/crud/guards/is-collection.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { EntityManifestService } from '../../manifest/services/entity-manifest.service';
+export declare class IsCollectionGuard implements CanActivate {
+    private readonly entityManifestService;
+    constructor(entityManifestService: EntityManifestService);
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/manifest/src/crud/guards/is-single.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { EntityManifestService } from '../../manifest/services/entity-manifest.service';
+export declare class IsSingleGuard implements CanActivate {
+    private readonly entityManifestService;
+    constructor(entityManifestService: EntityManifestService);
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/manifest/src/crud/services/crud.service.d.ts

@@ -0,0 +1,54 @@
+import { Repository } from 'typeorm';
+import { BaseEntity } from '@repo/types';
+import { EntityService } from '../../entity/services/entity.service';
+import { EntityManifest, Paginator, SelectOption } from '@repo/types';
+import { PaginationService } from './pagination.service';
+import { ValidationService } from '../../validation/services/validation.service';
+import { RelationshipService } from '../../entity/services/relationship.service';
+import { EntityManifestService } from '../../manifest/services/entity-manifest.service';
+export declare class CrudService {
+    private readonly entityService;
+    private readonly entityManifestService;
+    private readonly paginationService;
+    private readonly validationService;
+    private readonly relationshipService;
+    constructor(entityService: EntityService, entityManifestService: EntityManifestService, paginationService: PaginationService, validationService: ValidationService, relationshipService: RelationshipService);
+    findAll({ entitySlug, queryParams, fullVersion }: {
+        entitySlug: string;
+        queryParams?: {
+            [key: string]: string | string[];
+        };
+        fullVersion?: boolean;
+    }): Promise<Paginator<BaseEntity>>;
+    findSelectOptions({ entitySlug, queryParams }: {
+        entitySlug: string;
+        queryParams?: {
+            [key: string]: string | string[];
+        };
+    }): Promise<SelectOption[]>;
+    findOne({ entitySlug, id, queryParams, fullVersion }: {
+        entitySlug: string;
+        id: number;
+        queryParams?: {
+            [key: string]: string | string[];
+        };
+        fullVersion?: boolean;
+    }): Promise<BaseEntity>;
+    store(entitySlug: string, itemDto: Partial<BaseEntity>): Promise<BaseEntity>;
+    storeEmpty(entitySlug: string): Promise<BaseEntity>;
+    update({ entitySlug, id, itemDto, partialReplacement }: {
+        entitySlug: string;
+        id: number;
+        itemDto: Partial<BaseEntity>;
+        partialReplacement?: boolean;
+    }): Promise<BaseEntity>;
+    delete(entitySlug: string, id: number): Promise<BaseEntity>;
+    createWithDefaults({ repository, entityManifest, itemDto }: {
+        repository: Repository<BaseEntity>;
+        entityManifest: EntityManifest;
+        itemDto: Partial<BaseEntity>;
+    }): BaseEntity;
+    private getVisibleProps;
+    private loadRelations;
+    private filterQuery;
+}

package/dist/manifest/src/crud/services/database.service.d.ts

@@ -0,0 +1,8 @@
+import { ManifestService } from '../../manifest/services/manifest.service';
+import { EntityService } from '../../entity/services/entity.service';
+export declare class DatabaseService {
+    private manifestService;
+    private entityService;
+    constructor(manifestService: ManifestService, entityService: EntityService);
+    isDbEmpty(): Promise<boolean>;
+}

package/dist/manifest/src/crud/services/pagination.service.d.ts

@@ -0,0 +1,9 @@
+import { BaseEntity, Paginator } from '@repo/types';
+import { SelectQueryBuilder } from 'typeorm';
+export declare class PaginationService {
+    paginate({ query, resultsPerPage, currentPage }: {
+        query?: SelectQueryBuilder<BaseEntity>;
+        currentPage: number;
+        resultsPerPage?: number;
+    }): Promise<Paginator<BaseEntity>>;
+}

package/dist/manifest/src/endpoint/endpoint.controller.d.ts

@@ -0,0 +1,12 @@
+import { Request, Response } from 'express';
+import { HandlerService } from '../handler/handler.service';
+export declare class EndpointController {
+    private readonly handlerService;
+    constructor(handlerService: HandlerService);
+    triggerGetEndpoint(req: Request, res: Response): Promise<unknown>;
+    triggerPostEndpoint(req: Request, res: Response): Promise<unknown>;
+    triggerPutEndpoint(req: Request, res: Response): Promise<unknown>;
+    triggerPatchEndpoint(req: Request, res: Response): Promise<unknown>;
+    triggerDeleteEndpoint(req: Request, res: Response): Promise<unknown>;
+    private handleRoute;
+}

package/dist/manifest/src/endpoint/endpoint.module.d.ts

@@ -0,0 +1,4 @@
+import { MiddlewareConsumer } from '@nestjs/common';
+export declare class EndpointModule {
+    configure(consumer: MiddlewareConsumer): void;
+}

package/dist/manifest/src/endpoint/endpoint.service.d.ts

@@ -0,0 +1,17 @@
+import { EndpointSchema, EndpointManifest, HttpMethod } from '@repo/types';
+import { PolicyService } from '../policy/policy.service';
+export declare class EndpointService {
+    private readonly policyService;
+    constructor(policyService: PolicyService);
+    transformEndpointsSchemaObject(endpointSchemaObject: {
+        [k: string]: EndpointSchema;
+    }): EndpointManifest[];
+    matchRoutePath({ path, method, endpoints }: {
+        path: string;
+        method: HttpMethod;
+        endpoints: EndpointManifest[];
+    }): {
+        endpoint: EndpointManifest;
+        params: object;
+    };
+}

package/dist/manifest/src/endpoint/middlewares/match-endpoint.middleware.d.ts

@@ -0,0 +1,10 @@
+import { NestMiddleware } from '@nestjs/common';
+import { Request, Response } from 'express';
+import { EndpointService } from '../endpoint.service';
+import { ManifestService } from '../../manifest/services/manifest.service';
+export declare class MatchEndpointMiddleware implements NestMiddleware {
+    private readonly endpointService;
+    private readonly manifestService;
+    constructor(endpointService: EndpointService, manifestService: ManifestService);
+    use(req: Request, res: Response, next: () => void): void;
+}

package/dist/manifest/src/entity/columns/mysql-prop-type-column-types.d.ts

@@ -0,0 +1,3 @@
+import { PropType } from '@repo/types';
+import { ColumnType } from 'typeorm';
+export declare const mysqlPropTypeColumnTypes: Record<PropType, ColumnType>;

package/dist/manifest/src/entity/columns/mysql-prop-type-column-types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mysqlPropTypeColumnTypes = void 0;
+const types_1 = require("../../../../types/src");
+exports.mysqlPropTypeColumnTypes = {
+    [types_1.PropType.String]: 'varchar',
+    [types_1.PropType.Number]: 'decimal',
+    [types_1.PropType.Link]: 'varchar',
+    [types_1.PropType.Text]: 'text',
+    [types_1.PropType.RichText]: 'text',
+    [types_1.PropType.Money]: 'decimal',
+    [types_1.PropType.Date]: 'date',
+    [types_1.PropType.Timestamp]: 'datetime',
+    [types_1.PropType.Email]: 'varchar',
+    [types_1.PropType.Boolean]: 'tinyint',
+    [types_1.PropType.Password]: 'varchar',
+    [types_1.PropType.Choice]: 'varchar',
+    [types_1.PropType.Location]: 'json',
+    [types_1.PropType.File]: 'varchar',
+    [types_1.PropType.Image]: 'json'
+};

package/dist/manifest/src/entity/columns/postgres-prop-type-column-types copy.d.ts

@@ -0,0 +1,3 @@
+import { PropType } from '@repo/types';
+import { ColumnType } from 'typeorm';
+export declare const postgresPropTypeColumnTypes: Record<PropType, ColumnType>;

package/dist/manifest/src/entity/columns/sqlite-prop-type-column-types.d.ts

@@ -0,0 +1,3 @@
+import { PropType } from '@repo/types';
+import { ColumnType } from 'typeorm';
+export declare const sqlitePropTypeColumnTypes: Record<PropType, ColumnType>;

package/dist/manifest/src/entity/entity.module.d.ts

@@ -0,0 +1,2 @@
+export declare class EntityModule {
+}