@drax/dashboard-back 0.37.0

package/dist/controllers/DashboardController.js

@@ -0,0 +1,18 @@
+import DashboardServiceFactory from "../factory/services/DashboardServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import DashboardPermissions from "../permissions/DashboardPermissions.js";
+class DashboardController extends AbstractFastifyController {
+    constructor() {
+        super(DashboardServiceFactory.instance, DashboardPermissions);
+        this.tenantField = "tenant";
+        this.userField = "user";
+        this.tenantFilter = false;
+        this.userFilter = false;
+        this.tenantSetter = false;
+        this.userSetter = false;
+        this.tenantAssert = false;
+        this.userAssert = false;
+    }
+}
+export default DashboardController;
+export { DashboardController };

package/dist/factory/services/DashboardServiceFactory.js

@@ -0,0 +1,15 @@
+import DashboardRepository from '../../repository/DashboardRepository.js';
+import { DashboardService } from '../../services/DashboardService.js';
+import { DashboardBaseSchema } from "../../schemas/DashboardSchema.js";
+class DashboardServiceFactory {
+    static get instance() {
+        if (!DashboardServiceFactory.service) {
+            const repository = new DashboardRepository();
+            const schema = DashboardBaseSchema;
+            DashboardServiceFactory.service = new DashboardService(repository, schema);
+        }
+        return DashboardServiceFactory.service;
+    }
+}
+export default DashboardServiceFactory;
+export { DashboardServiceFactory };

package/dist/index.js

@@ -0,0 +1,9 @@
+import DashboardPermissions from './permissions/DashboardPermissions.js';
+import DashboardSchema from './schemas/DashboardSchema.js';
+import DashboardModel from './models/DashboardModel.js';
+import DashboardRepository from './repository/DashboardRepository.js';
+import DashboardService from './services/DashboardService.js';
+import DashboardServiceFactory from './factory/services/DashboardServiceFactory.js';
+import DashboardController from './controllers/DashboardController.js';
+import DashboardRoutes from './routes/DashboardRoutes.js';
+export { DashboardPermissions, DashboardSchema, DashboardModel, DashboardRepository, DashboardService, DashboardServiceFactory, DashboardController, DashboardRoutes };

package/dist/interfaces/IDashboard.js

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

package/dist/interfaces/IDashboardRepository.js

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

package/dist/models/DashboardModel.js

@@ -0,0 +1,65 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const DashboardSchema = new mongoose.Schema({
+    identifier: { type: String, required: true, index: true, unique: true },
+    title: { type: String, required: true, index: true, unique: true },
+    cards: [{
+            title: { type: String, required: true, index: false, unique: false },
+            entity: { type: String, required: true, index: false, unique: false },
+            type: { type: String, enum: ['paginate', 'groupBy'], required: true, index: false, unique: false },
+            filters: [{
+                    field: { type: String, required: true, index: false, unique: false },
+                    operator: { type: String, required: true, index: false, unique: false },
+                    value: { type: String, required: true, index: false, unique: false }
+                }],
+            layout: {
+                cols: { type: Number, required: true, index: false, unique: false },
+                sm: { type: Number, required: true, index: false, unique: false },
+                md: { type: Number, required: true, index: false, unique: false },
+                lg: { type: Number, required: true, index: false, unique: false },
+                height: { type: Number, required: true, index: false, unique: false },
+                cardVariant: {
+                    type: String,
+                    enum: ['text', 'flat', 'elevated', 'tonal', 'outlined', 'plain'],
+                    required: true,
+                    index: false,
+                    unique: false
+                }
+            },
+            groupBy: {
+                fields: [{ type: String, required: true, index: false, unique: false }],
+                dateFormat: {
+                    type: String,
+                    enum: ['year', 'month', 'day', 'hour', 'minute', 'second'],
+                    required: false,
+                    index: false,
+                    unique: false
+                },
+                render: {
+                    type: String,
+                    enum: ['table', 'gallery', 'pie', 'bars'],
+                    required: false,
+                    index: false,
+                    unique: false
+                }
+            },
+            paginate: {
+                columns: [{ type: String, required: true, index: false, unique: false }],
+                orderBy: { type: String, required: false, index: false, unique: false },
+                order: { type: String, enum: ['asc', 'desc', null], required: false, index: false, unique: false }
+            }
+        }]
+}, { timestamps: true });
+DashboardSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+DashboardSchema.plugin(mongoosePaginate);
+DashboardSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+DashboardSchema.set('toJSON', { getters: true, virtuals: true });
+DashboardSchema.set('toObject', { getters: true, virtuals: true });
+const MODEL_NAME = 'Dashboard';
+const COLLECTION_NAME = 'Dashboard';
+const DashboardModel = mongoose.model(MODEL_NAME, DashboardSchema, COLLECTION_NAME);
+export { DashboardSchema, DashboardModel };
+export default DashboardModel;

package/dist/permissions/DashboardPermissions.js

@@ -0,0 +1,10 @@
+var DashboardPermissions;
+(function (DashboardPermissions) {
+    DashboardPermissions["Create"] = "dashboard:create";
+    DashboardPermissions["Update"] = "dashboard:update";
+    DashboardPermissions["Delete"] = "dashboard:delete";
+    DashboardPermissions["View"] = "dashboard:view";
+    DashboardPermissions["Manage"] = "dashboard:manage";
+})(DashboardPermissions || (DashboardPermissions = {}));
+export { DashboardPermissions };
+export default DashboardPermissions;

package/dist/repository/DashboardRepository.js

@@ -0,0 +1,12 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { DashboardModel } from "../models/DashboardModel.js";
+class DashboardMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = DashboardModel;
+        this._searchFields = ['identifier', 'title'];
+        this._populateFields = [];
+    }
+}
+export default DashboardMongoRepository;
+export { DashboardMongoRepository };

package/dist/routes/DashboardRoutes.js

@@ -0,0 +1,18 @@
+import DashboardController from "../controllers/DashboardController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { DashboardSchema, DashboardBaseSchema } from '../schemas/DashboardSchema.js';
+async function DashboardFastifyRoutes(fastify, options) {
+    const controller = new DashboardController();
+    const schemas = new CrudSchemaBuilder(DashboardSchema, DashboardBaseSchema, DashboardBaseSchema, 'Dashboard', 'openApi3', ['dashboard']);
+    fastify.get('/api/dashboard', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/dashboard/find', { schema: schemas.findSchema }, (req, rep) => controller.find(req, rep));
+    fastify.get('/api/dashboard/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
+    fastify.get('/api/dashboard/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));
+    fastify.get('/api/dashboard/find-one', { schema: schemas.findOneSchema }, (req, rep) => controller.findOne(req, rep));
+    fastify.get('/api/dashboard/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
+    fastify.post('/api/dashboard', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/dashboard/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/dashboard/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+}
+export default DashboardFastifyRoutes;
+export { DashboardFastifyRoutes };

package/dist/schemas/DashboardSchema.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+const DashboardBaseSchema = z.object({
+    identifier: z.string().min(1, 'validation.required'),
+    title: z.string().min(1, 'validation.required'),
+    cards: z.array(z.object({
+        entity: z.string().min(1, 'validation.required'),
+        type: z.enum(['paginate', 'groupBy']),
+        title: z.string().min(1, 'validation.required'),
+        filters: z.array(z.object({
+            field: z.string().min(1, 'validation.required'),
+            operator: z.string().min(1, 'validation.required'),
+            value: z.string().min(1, 'validation.required')
+        })).optional(),
+        layout: z.object({
+            cols: z.number().min(0, 'validation.required').default(12),
+            sm: z.number().min(0, 'validation.required').default(12),
+            md: z.number().min(0, 'validation.required').default(12),
+            lg: z.number().min(0, 'validation.required').default(12),
+            height: z.number().min(0, 'validation.required').default(100),
+            cardVariant: z.enum(['text', 'flat', 'elevated', 'tonal', 'outlined', 'plain']).default('elevated')
+        }),
+        groupBy: z.object({
+            fields: z.array(z.string()),
+            dateFormat: z.enum(['year', 'month', 'day', 'hour', 'minute', 'second']).optional().default('day'),
+            render: z.enum(['table', 'gallery', 'pie', 'bars']).optional().default('table')
+        }),
+        paginate: z.object({
+            columns: z.array(z.string()).default([]),
+            orderBy: z.string().optional().nullable(),
+            order: z.enum(['asc', 'desc']).optional().nullable()
+        })
+    })).optional()
+});
+const DashboardSchema = DashboardBaseSchema
+    .extend({
+    _id: z.string(),
+});
+export default DashboardSchema;
+export { DashboardSchema, DashboardBaseSchema };

package/dist/services/DashboardService.js

@@ -0,0 +1,8 @@
+import { AbstractService } from "@drax/crud-back";
+class DashboardService extends AbstractService {
+    constructor(DashboardRepository, schema) {
+        super(DashboardRepository, schema);
+    }
+}
+export default DashboardService;
+export { DashboardService };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@drax/dashboard-back",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.37.0",
+  "description": "Dahsboard backend",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "prepublish": "tsc && npm run copygql",
+    "tscrun": "tsc",
+    "clean": "rm -rf dist",
+    "copygql": "copyfiles -u 1 ./**/*.graphql dist/",
+    "tsc": "tsc -b tsconfig.json",
+    "test": "node --import tsx --test test/**/*",
+    "testService": "node --import tsx --test test/services/*.ts",
+    "testExports": "node --import tsx --test test/exports/*.ts",
+    "testWorkers": "node --import tsx --test test/workers/*.ts"
+  },
+  "author": "Cristian Incarnato & Drax Team",
+  "license": "ISC",
+  "dependencies": {
+    "@drax/crud-back": "^0.37.0",
+    "@drax/crud-share": "^0.37.0",
+    "mongoose": "^8.6.3",
+    "mongoose-paginate-v2": "^1.8.3"
+  },
+  "peerDependencies": {
+    "dayjs": "^1.11.13",
+    "mongoose-paginate-v2": "^1.8.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.10",
+    "copyfiles": "^2.4.1",
+    "mongoose-paginate-v2": "^1.8.3",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.6.2"
+  },
+  "gitHead": "0bca48d4b686fd9536a78d84f5befe6801238000"
+}

package/src/controllers/DashboardController.ts

@@ -0,0 +1,27 @@
+
+import DashboardServiceFactory from "../factory/services/DashboardServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import DashboardPermissions from "../permissions/DashboardPermissions.js";
+import type {IDashboard, IDashboardBase} from "../interfaces/IDashboard";
+
+class DashboardController extends AbstractFastifyController<IDashboard, IDashboardBase, IDashboardBase>   {
+
+    constructor() {
+        super(DashboardServiceFactory.instance, DashboardPermissions)
+        this.tenantField = "tenant";
+        this.userField = "user";
+        this.tenantFilter = false;
+        this.userFilter = false;
+        this.tenantSetter = false;
+        this.userSetter = false;
+        this.tenantAssert = false;
+        this.userAssert = false;
+    }
+
+}
+
+export default DashboardController;
+export {
+    DashboardController
+}
+

package/src/factory/services/DashboardServiceFactory.ts

@@ -0,0 +1,23 @@
+
+import DashboardRepository from '../../repository/DashboardRepository.js'
+import {DashboardService} from '../../services/DashboardService.js'
+import {DashboardBaseSchema} from "../../schemas/DashboardSchema.js";
+
+class DashboardServiceFactory {
+    private static service: DashboardService;
+
+    public static get instance(): DashboardService {
+        if (!DashboardServiceFactory.service) {
+            const repository = new DashboardRepository();
+            const schema = DashboardBaseSchema;
+            DashboardServiceFactory.service = new DashboardService(repository, schema);
+        }
+        return DashboardServiceFactory.service;
+    }
+}
+
+export default DashboardServiceFactory
+export {
+    DashboardServiceFactory
+}
+

package/src/index.ts

@@ -0,0 +1,25 @@
+import DashboardPermissions from './permissions/DashboardPermissions.js'
+import DashboardSchema from './schemas/DashboardSchema.js'
+import DashboardModel from './models/DashboardModel.js'
+import DashboardRepository from './repository/DashboardRepository.js'
+import DashboardService from './services/DashboardService.js'
+import DashboardServiceFactory from './factory/services/DashboardServiceFactory.js'
+import DashboardController from './controllers/DashboardController.js'
+import DashboardRoutes from './routes/DashboardRoutes.js'
+import type {IDashboard, IDashboardBase} from './interfaces/IDashboard'
+import type {IDashboardRepository} from './interfaces/IDashboardRepository'
+
+export type{
+    IDashboard, IDashboardBase,IDashboardRepository
+}
+
+export {
+    DashboardPermissions,
+    DashboardSchema,
+    DashboardModel,
+    DashboardRepository,
+    DashboardService,
+    DashboardServiceFactory,
+    DashboardController,
+    DashboardRoutes
+}

package/src/interfaces/IDashboard.ts

@@ -0,0 +1,75 @@
+interface IDashboardBase {
+    identifier: string
+    title: string
+    cards?: Array<{
+        entity: string
+        type: string
+        title: string
+        filters?: Array<{
+            field: string
+            operator: string
+            value: string
+        }>
+        layout?: {
+            cols: number
+            sm: number
+            md: number
+            lg: number
+            height: number
+            cardVariant: string
+        }
+        groupBy?: {
+            fields: Array<string>
+            dateFormat?: string
+            render?: string
+        }
+        paginate?: {
+            columns: Array<string>
+            orderBy?: string
+            order?: string
+        }
+    }>
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+interface IDashboard {
+    _id: string
+    identifier: string
+    title: string
+    cards?: Array<{
+        entity: string
+        type: string
+        title: string
+        filters?: Array<{
+            field: string
+            operator: string
+            value: string
+        }>
+        layout?: {
+            cols: number
+            sm: number
+            md: number
+            lg: number
+            height: number
+            cardVariant: string
+        }
+        groupBy?: {
+            fields: Array<string>
+            dateFormat?: string
+            render?: string
+        }
+        paginate?: {
+            columns: Array<string>
+            orderBy?: string
+            order?: string
+        }
+    }>
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+export type {
+    IDashboardBase,
+    IDashboard
+}

package/src/interfaces/IDashboardRepository.ts

@@ -0,0 +1,11 @@
+
+import type {IDashboard, IDashboardBase} from './IDashboard'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface IDashboardRepository extends IDraxCrudRepository<IDashboard, IDashboardBase, IDashboardBase>{
+
+}
+
+export {IDashboardRepository}
+
+

package/src/models/DashboardModel.ts

@@ -0,0 +1,79 @@
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {IDashboard} from '../interfaces/IDashboard'
+
+const DashboardSchema = new mongoose.Schema<IDashboard>({
+    identifier: {type: String, required: true, index: true, unique: true},
+    title: {type: String, required: true, index: true, unique: true},
+    cards: [{
+        title: {type: String, required: true, index: false, unique: false},
+        entity: {type: String, required: true, index: false, unique: false},
+        type: {type: String, enum: ['paginate', 'groupBy'], required: true, index: false, unique: false},
+        filters: [{
+            field: {type: String, required: true, index: false, unique: false},
+            operator: {type: String, required: true, index: false, unique: false},
+            value: {type: String, required: true, index: false, unique: false}
+        }],
+        layout: {
+            cols: {type: Number, required: true, index: false, unique: false},
+            sm: {type: Number, required: true, index: false, unique: false},
+            md: {type: Number, required: true, index: false, unique: false},
+            lg: {type: Number, required: true, index: false, unique: false},
+            height: {type: Number, required: true, index: false, unique: false},
+            cardVariant: {
+                type: String,
+                enum: ['text', 'flat', 'elevated', 'tonal', 'outlined', 'plain'],
+                required: true,
+                index: false,
+                unique: false
+            }
+        },
+        groupBy: {
+            fields: [{type: String, required: true, index: false, unique: false}],
+            dateFormat: {
+                type: String,
+                enum: ['year', 'month', 'day', 'hour', 'minute', 'second'],
+                required: false,
+                index: false,
+                unique: false
+            },
+            render: {
+                type: String,
+                enum: ['table', 'gallery', 'pie', 'bars'],
+                required: false,
+                index: false,
+                unique: false
+            }
+        },
+        paginate: {
+            columns: [{type: String, required: true, index: false, unique: false}],
+            orderBy: {type: String, required: false, index: false, unique: false},
+            order: {type: String, enum: ['asc', 'desc', null], required: false, index: false, unique: false}
+        }
+    }]
+}, {timestamps: true});
+
+DashboardSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+DashboardSchema.plugin(mongoosePaginate);
+
+DashboardSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+
+
+DashboardSchema.set('toJSON', {getters: true, virtuals: true});
+
+DashboardSchema.set('toObject', {getters: true, virtuals: true});
+
+const MODEL_NAME = 'Dashboard';
+const COLLECTION_NAME = 'Dashboard';
+const DashboardModel = mongoose.model<IDashboard, PaginateModel<IDashboard>>(MODEL_NAME, DashboardSchema, COLLECTION_NAME);
+
+export {
+    DashboardSchema,
+    DashboardModel
+}
+
+export default DashboardModel

package/src/permissions/DashboardPermissions.ts

@@ -0,0 +1,14 @@
+
+enum DashboardPermissions {
+
+    Create = "dashboard:create",
+    Update = "dashboard:update",
+    Delete = "dashboard:delete",
+    View = "dashboard:view",
+    Manage = "dashboard:manage"
+
+}
+
+export { DashboardPermissions };
+export default DashboardPermissions;
+

package/src/repository/DashboardRepository.ts

@@ -0,0 +1,21 @@
+
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {DashboardModel} from "../models/DashboardModel.js";
+import type {IDashboardRepository} from '../interfaces/IDashboardRepository'
+import type {IDashboard, IDashboardBase} from "../interfaces/IDashboard";
+
+
+class DashboardMongoRepository extends AbstractMongoRepository<IDashboard, IDashboardBase, IDashboardBase> implements IDashboardRepository {
+
+    constructor() {
+        super();
+        this._model = DashboardModel;
+        this._searchFields = ['identifier', 'title'];
+         this._populateFields = [];
+    }
+
+}
+
+export default DashboardMongoRepository
+export {DashboardMongoRepository}
+

package/src/routes/DashboardRoutes.ts

@@ -0,0 +1,30 @@
+
+import DashboardController from "../controllers/DashboardController.js";
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {DashboardSchema, DashboardBaseSchema} from '../schemas/DashboardSchema.js'
+
+async function DashboardFastifyRoutes(fastify, options) {
+
+    const controller: DashboardController = new DashboardController()
+    const schemas = new CrudSchemaBuilder(DashboardSchema, DashboardBaseSchema,DashboardBaseSchema, 'Dashboard', 'openApi3', ['dashboard']);
+
+    fastify.get('/api/dashboard', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
+    
+    fastify.get('/api/dashboard/find', {schema: schemas.findSchema}, (req,rep) => controller.find(req,rep))
+    fastify.get('/api/dashboard/search', {schema: schemas.searchSchema}, (req,rep) => controller.search(req,rep))
+    
+    fastify.get('/api/dashboard/:id', {schema: schemas.findByIdSchema}, (req,rep) => controller.findById(req,rep))
+    fastify.get('/api/dashboard/find-one', {schema: schemas.findOneSchema}, (req,rep) => controller.findOne(req,rep))
+    
+    fastify.get('/api/dashboard/group-by', {schema: schemas.groupBySchema}, (req,rep) => controller.groupBy(req,rep))
+
+    fastify.post('/api/dashboard', {schema: schemas.createSchema}, (req,rep) =>controller.create(req,rep))
+
+    fastify.put('/api/dashboard/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.update(req,rep))
+
+    fastify.delete('/api/dashboard/:id', {schema: schemas.deleteSchema}, (req,rep) =>controller.delete(req,rep))
+    
+}
+
+export default DashboardFastifyRoutes;
+export {DashboardFastifyRoutes}

package/src/schemas/DashboardSchema.ts

@@ -0,0 +1,48 @@
+import {z} from 'zod';
+
+
+const DashboardBaseSchema = z.object({
+    identifier: z.string().min(1, 'validation.required'),
+    title: z.string().min(1, 'validation.required'),
+    cards: z.array(
+        z.object({
+            entity: z.string().min(1, 'validation.required'),
+            type: z.enum(['paginate', 'groupBy']),
+            title: z.string().min(1, 'validation.required'),
+            filters: z.array(
+                z.object({
+                    field: z.string().min(1, 'validation.required'),
+                    operator: z.string().min(1, 'validation.required'),
+                    value: z.string().min(1, 'validation.required')
+                })
+            ).optional(),
+            layout: z.object({
+                cols: z.number().min(0, 'validation.required').default(12),
+                sm: z.number().min(0, 'validation.required').default(12),
+                md: z.number().min(0, 'validation.required').default(12),
+                lg: z.number().min(0, 'validation.required').default(12),
+                height: z.number().min(0, 'validation.required').default(100),
+                cardVariant: z.enum(['text', 'flat', 'elevated', 'tonal', 'outlined', 'plain']).default('elevated')
+            }),
+            groupBy: z.object({
+                fields: z.array(z.string()),
+                dateFormat: z.enum(['year', 'month', 'day', 'hour', 'minute', 'second']).optional().default('day'),
+                render: z.enum(['table', 'gallery', 'pie', 'bars']).optional().default('table')
+            }),
+            paginate: z.object({
+                columns: z.array(z.string()).default([]),
+                orderBy: z.string().optional().nullable(),
+                order: z.enum(['asc', 'desc']).optional().nullable()
+            })
+        })
+    ).optional()
+});
+
+const DashboardSchema = DashboardBaseSchema
+    .extend({
+        _id: z.string(),
+
+    })
+
+export default DashboardSchema;
+export {DashboardSchema, DashboardBaseSchema}

package/src/services/DashboardService.ts

@@ -0,0 +1,16 @@
+
+import type{IDashboardRepository} from "../interfaces/IDashboardRepository";
+import type {IDashboardBase, IDashboard} from "../interfaces/IDashboard";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class DashboardService extends AbstractService<IDashboard, IDashboardBase, IDashboardBase> {
+
+    constructor(DashboardRepository: IDashboardRepository, schema?: ZodObject<ZodRawShape>) {
+        super(DashboardRepository, schema);
+    }
+
+}
+
+export default DashboardService
+export {DashboardService}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "declarationDir": "types"
+  },
+  "exclude": ["test", "types","dist","node_modules"],
+  "ts-node": {
+    "esm": true
+  },
+  "tsc-alias": {
+    "resolveFullPaths": true,
+    "verbose": false
+  }
+}