serene-core-server 0.1.1

package/dist/models/instances/instance-model.js

@@ -0,0 +1,432 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceModel = void 0;
+class InstanceModel {
+    constructor() {
+        // Consts
+        this.clName = 'InstanceModel';
+    }
+    // Code
+    create(prisma, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.create()`;
+            // Create record
+            try {
+                return yield prisma.instance.create({
+                    data: {
+                        parent: parentId != null ? {
+                            connect: {
+                                id: parentId
+                            }
+                        } : undefined,
+                        userProfile: {
+                            connect: {
+                                id: userProfileId
+                            }
+                        },
+                        instanceType: instanceType,
+                        projectType: projectType,
+                        isDemo: isDemo,
+                        isDefault: isDefault,
+                        status: status,
+                        publicAccess: publicAccess,
+                        name: name
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    deleteById(prisma, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteById()`;
+            // Delete
+            try {
+                return yield prisma.instance.delete({
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+        });
+    }
+    filter(prisma_1) {
+        return __awaiter(this, arguments, void 0, function* (prisma, parentId = undefined, userProfileId = undefined, instanceType = undefined, projectType = undefined, isDemo = undefined, isDefault = undefined, status = undefined, publicAccess = undefined, includeUserProfile = false, includeUser = false) {
+            // Debug
+            const fnName = `${this.clName}.filter()`;
+            // console.log(`${fnName}: starting with parentId: ${parentId} ` +
+            //             `status: ${status} ` +
+            //             `includeUserProfile: ${includeUserProfile} ` +
+            //             `includeUser: ${includeUser}`)
+            // Query
+            try {
+                return yield prisma.instance.findMany({
+                    include: {
+                        userProfile: includeUserProfile ? {
+                            include: {
+                                user: includeUser
+                            }
+                        } : false
+                    },
+                    where: {
+                        parentId: parentId,
+                        userProfileId: userProfileId,
+                        instanceType: instanceType,
+                        projectType: projectType,
+                        isDemo: isDemo,
+                        isDefault: isDefault,
+                        status: status,
+                        publicAccess: publicAccess
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    getById(prisma_1, id_1) {
+        return __awaiter(this, arguments, void 0, function* (prisma, id, includeParent = false, includeUserProfile = false, includeUser = false) {
+            // Debug
+            const fnName = `${this.clName}.getById()`;
+            // Query
+            var instance = null;
+            try {
+                instance = yield prisma.instance.findUnique({
+                    include: {
+                        parent: includeParent,
+                        userProfile: includeUserProfile ? {
+                            include: {
+                                user: includeUser
+                            }
+                        } : false
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+            // Return
+            return instance;
+        });
+    }
+    getByNameAndIsAdminUserProfile(prisma, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByName()`;
+            // Query
+            var instance;
+            try {
+                instance = yield prisma.instance.findFirst({
+                    where: {
+                        userProfile: {
+                            isAdmin: true
+                        },
+                        name: name
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Return
+            return instance;
+        });
+    }
+    getByParentIdAndUserProfileIdAndIsDefault(prisma, parentId, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByParentIdAndUserProfileIdAndIsDefault()`;
+            // Query
+            var instance;
+            try {
+                instance = yield prisma.instance.findFirst({
+                    where: {
+                        parentId: parentId,
+                        userProfileId: userProfileId,
+                        isDefault: true
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Return
+            return instance;
+        });
+    }
+    getByParentIdAndName(prisma, parentId, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByParentIdAndName()`;
+            // console.log(`${fnName}: parentId: ${parentId} name: ${name} ` +
+            //             `userProfileId: ${userProfileId}`)
+            // Validate
+            if (name == null) {
+                console.error(`${fnName}: name == null`);
+                throw 'Validation error';
+            }
+            // Query
+            var instance;
+            try {
+                instance = yield prisma.instance.findFirst({
+                    where: {
+                        parentId: parentId,
+                        name: name
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Return
+            return instance;
+        });
+    }
+    getByParentIdAndNameAndUserProfileId(prisma, parentId, name, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByParentIdAndNameAndUserProfileId()`;
+            // console.log(`${fnName}: parentId: ${parentId} name: ${name} ` +
+            //             `userProfileId: ${userProfileId}`)
+            // Validate
+            if (name == null) {
+                console.error(`${fnName}: name == null`);
+                throw 'Validation error';
+            }
+            if (userProfileId == null) {
+                console.error(`${fnName}: userProfileId == null`);
+                throw 'Validation error';
+            }
+            // Query
+            var instance;
+            try {
+                instance = yield prisma.instance.findFirst({
+                    where: {
+                        parentId: parentId,
+                        name: name,
+                        userProfileId: userProfileId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Return
+            return instance;
+        });
+    }
+    getByUserProfileIdAndName(prisma, userProfileId, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByUserProfileIdAndName()`;
+            // Query
+            var instance;
+            try {
+                instance = yield prisma.instance.findFirst({
+                    where: {
+                        userProfileId: userProfileId,
+                        name: name
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Return
+            return instance;
+        });
+    }
+    getByUserProfileIdAndParentNameAndName(prisma, userProfileId, parentName, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByUserProfileIdAndParentNameAndName()`;
+            // Validate
+            if (userProfileId == null) {
+                console.error(`${fnName}: userProfileId == null`);
+                throw 'Validation error';
+            }
+            if (parentName == null) {
+                console.error(`${fnName}: parentName == null`);
+                throw 'Validation error';
+            }
+            if (name == null) {
+                console.error(`${fnName}: name == null`);
+                throw 'Validation error';
+            }
+            // Query
+            var instance;
+            try {
+                instance = yield prisma.instance.findFirst({
+                    where: {
+                        parent: {
+                            userProfileId: userProfileId,
+                            parentId: null,
+                            name: parentName
+                        },
+                        userProfileId: userProfileId,
+                        name: name
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Return
+            return instance;
+        });
+    }
+    update(prisma, id, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Update record
+            try {
+                return yield prisma.instance.update({
+                    data: {
+                        parentId: parentId,
+                        userProfileId: userProfileId,
+                        instanceType: instanceType,
+                        projectType: projectType,
+                        isDemo: isDemo,
+                        isDefault: isDefault,
+                        status: status,
+                        publicAccess: publicAccess,
+                        name: name
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    updateByParentId(prisma, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.updateByParentId()`;
+            // Update record
+            try {
+                return yield prisma.instance.updateMany({
+                    data: {
+                        userProfileId: userProfileId,
+                        instanceType: instanceType,
+                        projectType: projectType,
+                        isDemo: isDemo,
+                        isDefault: isDefault,
+                        status: status,
+                        publicAccess: publicAccess,
+                        name: name
+                    },
+                    where: {
+                        parentId: parentId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    upsert(prisma, id, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.upsert()`;
+            // If id isn't specified, try to get by the unique key
+            if (id == null &&
+                parentId !== undefined &&
+                name != null &&
+                userProfileId != null) {
+                const instance = yield this.getByParentIdAndNameAndUserProfileId(prisma, parentId, name, userProfileId);
+                if (instance != null) {
+                    id = instance.id;
+                }
+            }
+            // Upsert
+            if (id == null) {
+                // Validate for create (mainly for type validation of the create call)
+                if (parentId === undefined) {
+                    console.error(`${fnName}: id is null and parentId is undefined`);
+                    throw 'Prisma error';
+                }
+                if (userProfileId == null) {
+                    console.error(`${fnName}: id is null and userProfileId is null`);
+                    throw 'Prisma error';
+                }
+                if (instanceType == null) {
+                    console.error(`${fnName}: id is null and instanceType is null`);
+                    throw 'Prisma error';
+                }
+                if (projectType === undefined) {
+                    console.error(`${fnName}: id is null and projectType is undefined`);
+                    throw 'Prisma error';
+                }
+                if (isDemo == null) {
+                    console.error(`${fnName}: id is null and isDemo is null`);
+                    throw 'Prisma error';
+                }
+                if (isDefault == null) {
+                    console.error(`${fnName}: id is null and isDefault is null`);
+                    throw 'Prisma error';
+                }
+                if (status == null) {
+                    console.error(`${fnName}: id is null and status is null`);
+                    throw 'Prisma error';
+                }
+                if (publicAccess === undefined) {
+                    console.error(`${fnName}: id is null and publicAccess is undefined`);
+                    throw 'Prisma error';
+                }
+                if (name == null) {
+                    console.error(`${fnName}: id is null and name is null`);
+                    throw 'Prisma error';
+                }
+                // Create
+                return yield this.create(prisma, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, name);
+            }
+            else {
+                // Update
+                return yield this.update(prisma, id, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, name);
+            }
+        });
+    }
+}
+exports.InstanceModel = InstanceModel;

package/dist/models/instances/instance-setting-model.d.ts

@@ -0,0 +1,39 @@
+import { Prisma } from '@prisma/client';
+export declare class InstanceSettingModel {
+    clName: string;
+    create(prisma: Prisma.TransactionClient, instanceId: string, name: string, value: string): Promise<{
+        name: string;
+        id: string;
+        value: string;
+        created: Date;
+        updated: Date;
+        instanceId: string;
+    }>;
+    deleteByInstanceId(prisma: Prisma.TransactionClient, instanceId: string): Promise<Prisma.BatchPayload>;
+    filter(prisma: Prisma.TransactionClient, instanceId: string | undefined, name: string | undefined, value: string | undefined): Promise<{
+        name: string;
+        id: string;
+        value: string;
+        created: Date;
+        updated: Date;
+        instanceId: string;
+    }[]>;
+    getById(prisma: Prisma.TransactionClient, id: string): Promise<any>;
+    getByInstanceIdAndName(prisma: Prisma.TransactionClient, instanceId: string, name: string): Promise<any>;
+    update(prisma: Prisma.TransactionClient, id: string, instanceId: string | undefined, name: string | undefined, value: string | undefined): Promise<{
+        name: string;
+        id: string;
+        value: string;
+        created: Date;
+        updated: Date;
+        instanceId: string;
+    }>;
+    upsert(prisma: Prisma.TransactionClient, id: string | undefined, instanceId: string | undefined, name: string | undefined, value: string | undefined): Promise<{
+        name: string;
+        id: string;
+        value: string;
+        created: Date;
+        updated: Date;
+        instanceId: string;
+    }>;
+}

package/dist/models/instances/instance-setting-model.js

@@ -0,0 +1,193 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceSettingModel = void 0;
+class InstanceSettingModel {
+    constructor() {
+        // Consts
+        this.clName = 'InstanceSettingModel';
+    }
+    // Code
+    create(prisma, instanceId, name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.create()`;
+            // Create record
+            try {
+                return yield prisma.instanceSetting.create({
+                    data: {
+                        instanceId: instanceId,
+                        name: name,
+                        value: value
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    deleteByInstanceId(prisma, instanceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteByInstanceId()`;
+            // Delete records
+            try {
+                return yield prisma.instanceSetting.deleteMany({
+                    where: {
+                        instanceId: instanceId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    filter(prisma, instanceId, name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.filter()`;
+            // console.log(`${fnName}: starting..`)
+            // Query
+            try {
+                return yield prisma.instanceSetting.findMany({
+                    where: {
+                        instanceId: instanceId,
+                        name: name,
+                        value: value
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    getById(prisma, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getById()`;
+            // Query
+            var instanceSetting = null;
+            try {
+                instanceSetting = yield prisma.instanceSetting.findUnique({
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                if (!(error instanceof error.NotFound)) {
+                    console.error(`${fnName}: error: ${error}`);
+                    throw 'Prisma error';
+                }
+            }
+            // Return
+            return instanceSetting;
+        });
+    }
+    getByInstanceIdAndName(prisma, instanceId, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByInstanceIdAndName()`;
+            // Validate
+            if (instanceId == null) {
+                console.error(`${fnName}: instanceId == null`);
+                throw 'Validation error';
+            }
+            if (name == null) {
+                console.error(`${fnName}: name == null`);
+                throw 'Validation error';
+            }
+            // Query
+            var instanceSetting;
+            try {
+                instanceSetting = yield prisma.instanceSetting.findFirst({
+                    where: {
+                        instanceId: instanceId,
+                        name: name
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+            // Return
+            return instanceSetting;
+        });
+    }
+    update(prisma, id, instanceId, name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Update record
+            try {
+                return yield prisma.instanceSetting.update({
+                    data: {
+                        instanceId: instanceId,
+                        name: name,
+                        value: value
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    upsert(prisma, id, instanceId, name, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.upsert()`;
+            // If id isn't specified, try to get by the unique key
+            if (id == null &&
+                instanceId != null &&
+                name != null) {
+                const instanceSetting = yield this.getByInstanceIdAndName(prisma, instanceId, name);
+                if (instanceSetting != null) {
+                    id = instanceSetting.id;
+                }
+            }
+            // Upsert
+            if (id == null) {
+                // Validate for create (mainly for type validation of the create call)
+                if (instanceId == null) {
+                    console.error(`${fnName}: id is null and instanceId is null`);
+                    throw 'Prisma error';
+                }
+                if (name == null) {
+                    console.error(`${fnName}: id is null and name is null`);
+                    throw 'Prisma error';
+                }
+                if (value == null) {
+                    console.error(`${fnName}: id is null and value is null`);
+                    throw 'Prisma error';
+                }
+                // Create
+                return yield this.create(prisma, instanceId, name, value);
+            }
+            else {
+                // Update
+                return yield this.update(prisma, id, instanceId, name, value);
+            }
+        });
+    }
+}
+exports.InstanceSettingModel = InstanceSettingModel;

package/dist/models/mailing-lists/mailing-list-model.d.ts

@@ -0,0 +1,34 @@
+import { PrismaClient } from '@prisma/client';
+export declare class MailingListModel {
+    clName: string;
+    create(prisma: PrismaClient, name: string, title: string): Promise<{
+        name: string;
+        id: string;
+        title: string;
+        created: Date;
+        updated: Date;
+    }>;
+    getAll(prisma: PrismaClient): Promise<{
+        name: string;
+        id: string;
+        title: string;
+        created: Date;
+        updated: Date;
+    }[]>;
+    getById(prisma: PrismaClient, id: string): Promise<any>;
+    getByName(prisma: PrismaClient, name: string): Promise<any>;
+    update(prisma: PrismaClient, id: string, name: string, title: string): Promise<{
+        name: string;
+        id: string;
+        title: string;
+        created: Date;
+        updated: Date;
+    }>;
+    upsert(prisma: PrismaClient, id: string, name: string, title: string): Promise<{
+        name: string;
+        id: string;
+        title: string;
+        created: Date;
+        updated: Date;
+    }>;
+}