@lilaquadrat/studio 10.0.0-beta.5 → 10.0.0-beta.51

package/lib/src/services/domains.service.js

@@ -1,10 +1,6 @@
-import { ObjectId } from 'mongodb';
 import DNS from 'dns';
 import Immutable from '../Immutable.class.js';
 import DomainModel from '../models/domain.model.js';
-import certificatesService from './certificates.service.js';
-import HostingModel from '../models/hosting.model.js';
-import certificatesActionService from './certificatesAction.service.js';
 import secretService from './secret.service.js';
 const dns = DNS.promises;
 class DomainsService extends Immutable {
@@ -12,112 +8,6 @@ class DomainsService extends Immutable {
         super(...arguments);
         this.model = DomainModel;
     }
-    async single(internalId, options) {
-        const projection = {};
-        const aggregationArray = [
-            {
-                $match: {
-                    $and: [
-                        { $expr: { $eq: ['$_id', internalId] } },
-                    ],
-                },
-            },
-        ];
-        if (!options?.includeSecret) {
-            projection.secret = false;
-        }
-        if (!options?.certificate) {
-            projection.certificate = false;
-        }
-        if (Object.keys(projection).length) {
-            aggregationArray.push({
-                $project: projection,
-            });
-        }
-        if (options?.includeSecret) {
-            aggregationArray.push({
-                $lookup: {
-                    from: 'secrets',
-                    as: 'secret',
-                    let: { referenceId: '$secret' },
-                    pipeline: [
-                        {
-                            $match: {
-                                $and: [
-                                    { $expr: { $eq: ['$_id', '$$referenceId'] } },
-                                ],
-                            },
-                        },
-                        {
-                            $project: {
-                                key: 1,
-                                id: 1,
-                                _id: 0,
-                            },
-                        },
-                    ],
-                },
-            });
-            aggregationArray.push({
-                $unwind: {
-                    path: '$secret',
-                    preserveNullAndEmptyArrays: true,
-                },
-            });
-        }
-        if (options?.certificate) {
-            aggregationArray.push({
-                $lookup: {
-                    from: 'certificates',
-                    as: 'certificate',
-                    let: { certificateId: '$certificate' },
-                    pipeline: [
-                        {
-                            $match: {
-                                $and: [
-                                    { $expr: { $eq: ['$_id', { $toObjectId: '$$certificateId' }] } },
-                                ],
-                            },
-                        },
-                        {
-                            $project: {
-                                _id: 1,
-                                domains: 1,
-                                valid: 1,
-                                type: 1,
-                                contentType: 1,
-                                filename: 1,
-                            },
-                        },
-                    ],
-                },
-            });
-            aggregationArray.push({
-                $unwind: {
-                    path: '$certificate',
-                    preserveNullAndEmptyArrays: true,
-                },
-            });
-        }
-        const domain = await this.model.db.aggregate(aggregationArray).toArray();
-        if (domain[0])
-            return domain[0];
-        return undefined;
-    }
-    /**
-     * @deprecated
-     */
-    async createWithSSL(data, user, app) {
-        const newDomain = await this.create({ ...data, validated: false }, user, app);
-        const secret = await secretService.singleUpsert(data.company, data.project, undefined, undefined, data.domain, 10, user, app);
-        /** set the dns validation secret */
-        await this.immutable(newDomain._id, { secret: secret._id }, user, 'change', app, undefined, undefined, 'setSecret');
-        const certOrRequest = await certificatesService.getOrRequest(data.domain, data.company, data.project, user, app);
-        if (certOrRequest.type === 'certificate') {
-            await this.linkCertificate(new ObjectId(certOrRequest.data?._id), data.domain, data.company, data.project, user, app);
-        }
-        return newDomain;
-    }
     async createWithSecret(data, options) {
         const newDomain = await this.create({ ...data, validated: false }, options.user, options.app);
         const secret = await secretService.singleUpsert(data.company, data.project, undefined, undefined, data.domain, 10, options.user, options.app);
@@ -125,29 +15,6 @@ class DomainsService extends Immutable {
         await this.immutable(newDomain._id, { secret: secret._id }, options.user, 'change', options.app, undefined, undefined, 'setSecret');
         return newDomain;
     }
-    async createWithWildcard(data, options) {
-        const newDomain = await this.create({ ...data, validated: true }, options.user, options.app);
-        const certOrRequest = await certificatesService.getOrRequestWildcard(data.domain, options);
-        if (certOrRequest.type === 'certificate') {
-            await this.linkCertificate(new ObjectId(certOrRequest.data?._id), data.domain, undefined, undefined, options.user, options.app);
-        }
-        return newDomain;
-    }
-    /**
-     * start a new certification action based upon the last failed for this domain
-     */
-    async retrySSL(data, user, app) {
-        const failedAction = await certificatesActionService.latest(data.domain, data.company, data.project);
-        if (failedAction?.state === 'failed') {
-            return certificatesActionService.request(failedAction.domains, failedAction.type, failedAction.contentType, failedAction.renew, {
-                company: failedAction.company,
-                project: failedAction.project,
-                user,
-                app,
-            });
-        }
-        return null;
-    }
     async remove(_id, user, app) {
         const domain = await this.model.db.findOne({ _id });
         if (!domain)
@@ -156,29 +23,49 @@ class DomainsService extends Immutable {
             throw new Error('DOMAIN_IS_DEFAULT');
         return this.delete(_id, user, app);
     }
-    linkCertificate(certificateInternalId, domain, company, project, user, app) {
-        return this.immutable({ domain, company, project }, { certificate: certificateInternalId }, user, 'change', app, undefined, undefined, 'setCertificate');
-    }
-    linkMultipleDomains(certificateInternalId, domains, company, project, user, app) {
-        const PROMISEARRAY = domains.map((domain) => this.linkCertificate(new ObjectId(certificateInternalId), domain, company, project, user, app));
-        return Promise.all(PROMISEARRAY);
-    }
     /**
      * In order to bind a domain to lilaquadrat STUDIO, the ownership of the domains needs to be validated.
      * a TXT entry with ``lila-studio-SECRET`` needs to be added to the DNS
      */
     async validateDnsSecret(domain, key) {
-        const records = await dns.resolveTxt(domain);
-        const searchString = `lila-studio-${key}`;
-        return records.some(record => record.some(entry => entry.includes(searchString)));
+        try {
+            const records = await dns.resolveTxt(domain);
+            const searchString = `lila-studio-${key}`;
+            return records.some(record => record.some(entry => entry.includes(searchString)));
+        }
+        catch (error) {
+            // ENODATA means no TXT records exist, which means validation fails
+            if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') {
+                return false;
+            }
+            throw error;
+        }
     }
-    /**
-     * In order to bind a domain to lilaquadrat STUDIO, the ownership of the domains needs to be validated.
-     * a TXT entry with ``lila-studio-SECRET`` needs to be added to the DNS
-     */
     async validateDnsARecord(domain, ip) {
-        const records = await dns.resolve4(domain);
-        return records.some((record) => record.includes(ip));
+        try {
+            const records = await dns.resolve4(domain);
+            return records.some((record) => record.includes(ip));
+        }
+        catch (error) {
+            // ENODATA/ENOTFOUND means no A records exist, which means validation fails
+            if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async validateDnsAAAARecord(domain, ip) {
+        try {
+            const records = await dns.resolve6(domain);
+            return records.some((record) => record.includes(ip));
+        }
+        catch (error) {
+            // ENODATA/ENOTFOUND means no AAAA records exist, which means validation fails
+            if (error.code === 'ENODATA' || error.code === 'ENOTFOUND') {
+                return false;
+            }
+            throw error;
+        }
     }
     getDefaultDomain(company, project, hostingDomain) {
         return `${company}-${project}.${hostingDomain}`;
@@ -186,6 +73,25 @@ class DomainsService extends Immutable {
     getAllDomains() {
         return this.model.db.find().toArray();
     }
+    /**
+     * returns a string of domains and if a domain is set as "main" it will be not in the last
+     * @param company
+     * @param project
+     * @returns
+     */
+    async getDomainsWithMain(company, project) {
+        const allDomains = await this.getDomains(company, project);
+        const mainDomain = allDomains.find(domain => domain.isMain);
+        // If there's a main domain, exclude it from the domains array
+        // If there's no main domain, include all domains in the array
+        const domains = mainDomain
+            ? allDomains.filter(domain => !domain.isMain).map(domain => domain.domain)
+            : allDomains.map(domain => domain.domain);
+        return {
+            domains,
+            main: mainDomain?.domain,
+        };
+    }
     createDefaultDomain(company, project, options) {
         return this.immutableUpsert({
             company,
@@ -200,430 +106,56 @@ class DomainsService extends Immutable {
             validated: true,
         }, options.user, 'create', options.app);
     }
-    /**
-     * get all domains for specific project with ports and certificates
-     */
-    async getDomainsWithPorts(company, project) {
-        const hostingPorts = await HostingModel.db.findOne({ company, project, active: true });
-        if (!hostingPorts)
-            return [];
-        return this.model.db.aggregate([
-            {
-                $match: {
-                    $and: [
-                        {
-                            $expr: {
-                                $eq: ['$project', project],
-                            },
-                        },
-                        {
-                            $expr: {
-                                $eq: ['$company', company],
-                            },
-                        },
-                        {
-                            $expr: {
-                                $eq: ['$active', true],
-                            },
-                        },
-                        {
-                            $expr: {
-                                $eq: ['$validated', true],
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $lookup: {
-                    from: 'certificates',
-                    as: 'certificate',
-                    let: { certificateId: '$certificate' },
-                    pipeline: [
-                        {
-                            $match: {
-                                $and: [
-                                    { $expr: { $eq: ['$_id', { $toObjectId: '$$certificateId' }] } },
-                                ],
-                            },
-                        },
-                        {
-                            $project: {
-                                _id: 1,
-                                domains: 1,
-                                valid: 1,
-                                type: 1,
-                                contentType: 1,
-                                filename: 1,
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $unwind: {
-                    path: '$certificate',
-                    preserveNullAndEmptyArrays: true,
-                },
-            },
-            {
-                $project: {
-                    history: 0,
-                },
-            },
-            {
-                $addFields: {
-                    port: hostingPorts.port,
-                },
-            },
-        ]).toArray();
-    }
-    /**
-     * get all domains from active hosting with ports and certificates
-     */
-    async getAllDomainsWithPorts() {
-        return HostingModel.db.aggregate([
-            {
-                $match: {
-                    $and: [
-                        {
-                            $expr: {
-                                $eq: ['$active', true],
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $lookup: {
-                    from: 'domains',
-                    as: 'domains',
-                    let: {
-                        company: '$company',
-                        project: '$project',
+    single(internalId, options) {
+        if (options?.includeSecret) {
+            const aggregationArray = [
+                {
+                    $match: {
+                        _id: internalId,
+                        company: options.company,
+                        project: options.project,
                     },
-                    pipeline: [
-                        {
-                            $match: {
-                                $and: [
-                                    { $expr: { $eq: ['$company', '$$company'] } },
-                                    { $expr: { $eq: ['$project', '$$project'] } },
-                                    { $expr: { $eq: ['$active', true] } },
-                                ],
-                            },
-                        },
-                        {
-                            $project: {
-                                isDefault: 1,
-                                domain: 1,
-                                _id: 0,
-                            },
-                        },
-                    ],
                 },
-            },
-            {
-                $lookup: {
-                    from: 'certificates',
-                    as: 'certificate',
-                    let: { certificateId: '$certificate' },
-                    pipeline: [
-                        {
-                            $match: {
-                                $and: [
-                                    { $expr: { $eq: ['$_id', { $toObjectId: '$$certificateId' }] } },
-                                ],
-                            },
-                        },
-                        {
-                            $project: {
-                                _id: 1,
-                                domains: 1,
-                                valid: 1,
-                                type: 1,
-                                contentType: 1,
-                                filename: 1,
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $unwind: {
-                    path: '$certificate',
-                    preserveNullAndEmptyArrays: true,
-                },
-            },
-            {
-                $project: {
-                    history: 0,
-                },
-            },
-        ]).toArray();
-    }
-    getCustomQuery(filter, options) {
-        const match = {};
-        const matchLate = {};
-        if (filter?.domain) {
-            match.domain = filter.domain;
-        }
-        if (filter?.filterState?.includes('certificateNeeded')) {
-            matchLate.certificateNeeded = true;
-        }
-        const aggregation = [
-            {
-                $match: match,
-            },
-            {
-                $project: {
-                    secret: 0,
-                },
-            },
-            {
-                $lookup: {
-                    from: 'certificates',
-                    as: 'certificate',
-                    let: { certificateId: '$certificate' },
-                    pipeline: [
-                        {
-                            $match: {
-                                $and: [
-                                    { $expr: { $eq: ['$_id', { $toObjectId: '$$certificateId' }] } },
-                                ],
-                            },
-                        },
-                        {
-                            $addFields: {
-                                'valid.isValid': {
-                                    $cond: [
-                                        { $gt: ['$valid.to', new Date()] }, // condition
-                                        true, // value if true
-                                        false, // value if false
+                {
+                    $lookup: {
+                        from: 'secrets',
+                        as: 'secret',
+                        let: { referenceId: '$secret' },
+                        pipeline: [
+                            {
+                                $match: {
+                                    $and: [
+                                        { $expr: { $eq: ['$_id', '$$referenceId'] } },
                                     ],
                                 },
                             },
-                        },
-                        {
-                            $project: {
-                                _id: 1,
-                                domains: 1,
-                                valid: 1,
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $lookup: {
-                    from: 'hosting',
-                    as: 'hosting',
-                    let: {
-                        company: '$company',
-                        project: '$project',
-                    },
-                    pipeline: [
-                        {
-                            $match: {
-                                $and: [
-                                    { $expr: { $eq: ['$company', '$$company'] } },
-                                    { $expr: { $eq: ['$project', '$$project'] } },
-                                ],
-                            },
-                        },
-                        {
-                            $project: {
-                                history: 0,
-                                port: 0,
-                                company: 0,
-                                project: 0,
-                                _id: 0,
-                            },
-                        },
-                    ],
-                },
-            },
-            {
-                $unwind: {
-                    path: '$certificate',
-                    preserveNullAndEmptyArrays: true,
-                },
-            },
-            {
-                $unwind: {
-                    path: '$hosting',
-                    preserveNullAndEmptyArrays: true,
-                },
-            },
-            {
-                $addFields: {
-                    'certificateNeeded': {
-                        $and: [
                             {
-                                $or: [
-                                    { $eq: ['$certificate.valid.isValid', false] },
-                                    { $eq: [{ $type: '$certificate.valid.isValid' }, 'missing'] },
-                                ],
+                                $project: {
+                                    key: 1,
+                                    id: 1,
+                                    _id: 0,
+                                },
                             },
-                            { $eq: ['$hosting.active', true] },
-                            { $eq: ['$isDefault', false] },
                         ],
                     },
                 },
-            },
-            {
-                $project: {
-                    history: 0,
+                {
+                    $unwind: {
+                        path: '$secret',
+                        preserveNullAndEmptyArrays: true,
+                    },
                 },
-            },
-            {
-                $match: matchLate,
-            },
-        ];
-        aggregation.push({
-            $sort: options.sort || { _id: -1 },
-        });
-        if (options.skip) { }
-        aggregation.push({
-            $skip: options.skip,
-        }, {
-            $limit: options.limit,
-        });
-        return { aggregation, countQuery: match };
-    }
-    /**
-      * add the ports to the domains
-      */
-    mapPortToRealPorts(domains, port) {
-        return domains.map((single) => {
-            single.ports = {
-                http: port.http + (single.port || 0),
-                https: port.https + (single.port || 0),
-            };
-            return single;
-        });
-    }
-    /**
-     *
-     * map the database format to the working format
-     */
-    mapDomains(domains) {
-        const mapped = {};
-        domains.forEach((single) => {
-            if (!mapped[`${single.company}${single.project}`]) {
-                mapped[`${single.company}${single.project}`] = {
-                    domains: [],
-                    company: single.company,
-                    project: single.project,
-                    port: single.port,
-                };
-            }
-            single.isDefault
-                ? (mapped[`${single.company}${single.project}`].defaultDomain = single.domain)
-                : mapped[`${single.company}${single.project}`].domains.push(single.domain);
-        });
-        return Object.keys(mapped).map((key) => mapped[key]);
+            ];
+            return this.model.db.aggregate(aggregationArray).toArray()
+                .then((document) => document[0] || undefined);
+        }
+        return this.model.db.findOne({ _id: internalId, company: options.company, project: options.project });
     }
     /**
-     *
-     * map the database format to the working format
+     * get all active and validated domains for specific project
      */
-    mapDomainsProject(domains, options) {
-        if (!domains.length)
-            return null;
-        let defaultDomain;
-        const mappedHttp = {
-            domains: [],
-            company: domains[0]?.company,
-            project: domains[0]?.project,
-            port: options.http + domains[0]?.port,
-        };
-        const mappedHttps = [];
-        const redirectDomains = [];
-        domains.forEach((single) => {
-            if (single.isDefault) {
-                defaultDomain = {
-                    domains: [{ domain: single.domain, company: domains[0]?.company, project: domains[0]?.project }],
-                    company: domains[0]?.company,
-                    project: domains[0]?.project,
-                    isMain: single.isMain,
-                    ports: {
-                        http: options.http + single.port,
-                        https: options.https + single.port,
-                    },
-                };
-                return;
-            }
-            if (single.certificate) {
-                const certificate = single.certificate;
-                const httpsMapping = {
-                    domains: [{ domain: single.domain, company: domains[0]?.company, project: domains[0]?.project }],
-                    company: single.company,
-                    project: single.project,
-                    isMain: single.isMain,
-                    port: options.https + single.port,
-                    certificate: certificate.filename,
-                };
-                if (options.redirectToMainDomain && !single.isMain) {
-                    redirectDomains.push(httpsMapping);
-                }
-                else {
-                    mappedHttps.push(httpsMapping);
-                }
-                // if the certificate is created through the http challenge, the domain must always be reachable through http
-                if (certificate.type === 'domain') {
-                    mappedHttp.domains.push({ domain: single.domain, company: domains[0]?.company, project: domains[0]?.project });
-                }
-            }
-            else {
-                mappedHttp.domains.push({ domain: single.domain, company: domains[0]?.company, project: domains[0]?.project });
-            }
-        });
-        const returnObject = {
-            http: mappedHttp,
-            https: mappedHttps,
-            defaultDomain,
-            redirectDomains,
-        };
-        return returnObject;
-    }
-    async getOrRequestForProject(company, project, options) {
-        const domains = await this.model.db.find({
-            company,
-            project,
-            validated: true,
-            active: true,
-            isDefault: false,
-        }).toArray();
-        return domains.map((single) => certificatesService.getOrRequest(single.domain, company, project, options.user, options.app));
-    }
-    async requestCertificateForDomain(internalId, options) {
-        const domain = await this.model.db.findOne({ _id: internalId });
-        if (!domain)
-            return null;
-        if (await certificatesActionService.actionExistsForDomain(domain.domain))
-            throw new Error('CERTIFICATEACTION_EXISTS');
-        if (!domain?.active && domain.company && domain.project)
-            throw new Error('DOMAIN_NOT_ACTIVE');
-        if (!domain?.validated)
-            throw new Error('DOMAIN_NOT_VALIDATED');
-        if (!domain.company && !domain.project) {
-            return certificatesActionService.request([domain.domain], 'wildcard', 'pem', true, {
-                app: options.app,
-                user: options.user,
-                forceFile: true,
-                timeout: 120,
-            });
-        }
-        else if (domain.company && domain.project) {
-            return certificatesActionService.request([domain.domain], 'domain', 'pem', true, {
-                ...options,
-                company: domain.company,
-                project: domain.project,
-                forceFile: true,
-                timeout: 120,
-            });
-        }
-        return null;
+    async getDomains(company, project) {
+        return this.model.db.find({ company, project, active: true, validated: true }).toArray();
     }
 }
 export default new DomainsService();