serene-core-server 0.1.1

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

@@ -0,0 +1,466 @@
+export class InstanceModel {
+    // Consts
+    clName = 'InstanceModel';
+    // Code
+    async create(prisma, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, key, name) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Create record
+        try {
+            return await 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,
+                    key: key,
+                    name: name
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.deleteById()`;
+        // Delete
+        try {
+            return await prisma.instance.delete({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async filter(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 await 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';
+        }
+    }
+    async getById(prisma, id, includeParent = false, includeUserProfile = false, includeUser = false) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Query
+        var instance = null;
+        try {
+            instance = await 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;
+    }
+    async getByNameAndIsAdminUserProfile(prisma, name) {
+        // Debug
+        const fnName = `${this.clName}.getByName()`;
+        // Query
+        var instance;
+        try {
+            instance = await prisma.instance.findFirst({
+                where: {
+                    userProfile: {
+                        isAdmin: true
+                    },
+                    name: name
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instance;
+    }
+    async getByParentIdAndUserProfileIdAndIsDefault(prisma, parentId, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.getByParentIdAndUserProfileIdAndIsDefault()`;
+        // Query
+        var instance;
+        try {
+            instance = await prisma.instance.findFirst({
+                where: {
+                    parentId: parentId,
+                    userProfileId: userProfileId,
+                    isDefault: true
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instance;
+    }
+    async getByParentIdAndKey(prisma, parentId, key) {
+        // Debug
+        const fnName = `${this.clName}.getByParentIdAndKey()`;
+        // console.log(`${fnName}: parentId: ${parentId} key: ${key} ` +
+        //             `userProfileId: ${userProfileId}`)
+        // Validate
+        if (key == null) {
+            console.error(`${fnName}: key == null`);
+            throw 'Validation error';
+        }
+        // Query
+        var instance;
+        try {
+            instance = await prisma.instance.findFirst({
+                where: {
+                    parentId: parentId,
+                    key: key
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instance;
+    }
+    async getByParentIdAndName(prisma, parentId, name) {
+        // 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 = await prisma.instance.findFirst({
+                where: {
+                    parentId: parentId,
+                    name: name
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instance;
+    }
+    async getByParentIdAndKeyAndUserProfileId(prisma, parentId, key, userProfileId) {
+        // Debug
+        const fnName = `${this.clName}.getByParentIdAndKeyAndUserProfileId()`;
+        // console.log(`${fnName}: parentId: ${parentId} key: ${key} ` +
+        //             `userProfileId: ${userProfileId}`)
+        // Validate
+        if (key == null) {
+            console.error(`${fnName}: key == null`);
+            throw 'Validation error';
+        }
+        if (userProfileId == null) {
+            console.error(`${fnName}: userProfileId == null`);
+            throw 'Validation error';
+        }
+        // Query
+        var instance;
+        try {
+            instance = await prisma.instance.findFirst({
+                where: {
+                    parentId: parentId,
+                    key: key,
+                    userProfileId: userProfileId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instance;
+    }
+    async getByParentIdAndNameAndUserProfileId(prisma, parentId, name, userProfileId) {
+        // 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 = await prisma.instance.findFirst({
+                where: {
+                    parentId: parentId,
+                    name: name,
+                    userProfileId: userProfileId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instance;
+    }
+    async getByUserProfileIdAndName(prisma, userProfileId, name) {
+        // Debug
+        const fnName = `${this.clName}.getByUserProfileIdAndName()`;
+        // Query
+        var instance;
+        try {
+            instance = await prisma.instance.findFirst({
+                where: {
+                    userProfileId: userProfileId,
+                    name: name
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instance;
+    }
+    async getByUserProfileIdAndParentNameAndName(prisma, userProfileId, parentName, name) {
+        // 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 = await 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;
+    }
+    async update(prisma, id, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, key, name) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Update record
+        try {
+            return await prisma.instance.update({
+                data: {
+                    parentId: parentId,
+                    userProfileId: userProfileId,
+                    instanceType: instanceType,
+                    projectType: projectType,
+                    isDemo: isDemo,
+                    isDefault: isDefault,
+                    status: status,
+                    publicAccess: publicAccess,
+                    key: key,
+                    name: name
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async updateByParentId(prisma, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, key, name) {
+        // Debug
+        const fnName = `${this.clName}.updateByParentId()`;
+        // Update record
+        try {
+            return await prisma.instance.updateMany({
+                data: {
+                    userProfileId: userProfileId,
+                    instanceType: instanceType,
+                    projectType: projectType,
+                    isDemo: isDemo,
+                    isDefault: isDefault,
+                    status: status,
+                    publicAccess: publicAccess,
+                    key: key,
+                    name: name
+                },
+                where: {
+                    parentId: parentId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, key, name) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // If id isn't specified, try to get by a unique key
+        if (id == null &&
+            parentId !== undefined &&
+            key != null &&
+            userProfileId != null) {
+            const instance = await this.getByParentIdAndKeyAndUserProfileId(prisma, parentId, key, userProfileId);
+            if (instance != null) {
+                id = instance.id;
+            }
+        }
+        if (id == null &&
+            parentId !== undefined &&
+            name != null &&
+            userProfileId != null) {
+            const instance = await 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 (key == null) {
+                console.error(`${fnName}: id is null and key is null`);
+                throw 'Prisma error';
+            }
+            if (name == null) {
+                console.error(`${fnName}: id is null and name is null`);
+                throw 'Prisma error';
+            }
+            // Create
+            return await this.create(prisma, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, key, name);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, parentId, userProfileId, instanceType, projectType, isDemo, isDefault, status, publicAccess, key, name);
+        }
+    }
+}

package/dist/src/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/src/models/instances/instance-setting-model.js

@@ -0,0 +1,164 @@
+export class InstanceSettingModel {
+    // Consts
+    clName = 'InstanceSettingModel';
+    // Code
+    async create(prisma, instanceId, name, value) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Create record
+        try {
+            return await prisma.instanceSetting.create({
+                data: {
+                    instanceId: instanceId,
+                    name: name,
+                    value: value
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteByInstanceId(prisma, instanceId) {
+        // Debug
+        const fnName = `${this.clName}.deleteByInstanceId()`;
+        // Delete records
+        try {
+            return await prisma.instanceSetting.deleteMany({
+                where: {
+                    instanceId: instanceId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async filter(prisma, instanceId, name, value) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // console.log(`${fnName}: starting..`)
+        // Query
+        try {
+            return await prisma.instanceSetting.findMany({
+                where: {
+                    instanceId: instanceId,
+                    name: name,
+                    value: value
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async getById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Query
+        var instanceSetting = null;
+        try {
+            instanceSetting = await prisma.instanceSetting.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return
+        return instanceSetting;
+    }
+    async getByInstanceIdAndName(prisma, instanceId, name) {
+        // 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 = await prisma.instanceSetting.findFirst({
+                where: {
+                    instanceId: instanceId,
+                    name: name
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+        // Return
+        return instanceSetting;
+    }
+    async update(prisma, id, instanceId, name, value) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Update record
+        try {
+            return await prisma.instanceSetting.update({
+                data: {
+                    instanceId: instanceId,
+                    name: name,
+                    value: value
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, instanceId, name, value) {
+        // 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 = await 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 await this.create(prisma, instanceId, name, value);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, instanceId, name, value);
+        }
+    }
+}

package/dist/src/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;
+    }>;
+}