@lilaquadrat/studio 10.0.0-beta.9 → 10.0.0

package/lib/src/services/domains.service.d.ts

@@ -1,108 +1,42 @@
 import { ObjectId, WithId } from 'mongodb';
 import Immutable from '../Immutable.class.js';
-import { Domain, ProjectDomain, Secret, Certificate, SystemDomain, Hosting, DomainsList, BasicData, DomainConf, HostingPorts, SkipLimitSort, UserApp, UserAppWithOptions, ListCustomQueries } from '@lilaquadrat/interfaces';
+import { Domain, ProjectDomain, ProjectDomainWithSecret, UserApp, Options, BasicData } from '@lilaquadrat/interfaces';
 declare class DomainsService extends Immutable<Domain> {
     model: import("../classes/modelv2.class.js").default<Domain, string>;
-    single(internalId: ObjectId, options: {
-        includeSecret: true;
-    }): Promise<WithId<Omit<ProjectDomain, 'secret'> & {
-        secret: Secret;
-    }>>;
-    single(internalId: ObjectId, options: {
-        certificate: true;
-    }): Promise<WithId<Omit<ProjectDomain, 'certificate'> & {
-        certificate: Certificate;
-    }>>;
-    single(internalId: ObjectId, options: {
-        includeSecret: true;
-        certificate: true;
-    }): Promise<WithId<Omit<ProjectDomain, 'secret' | 'certificate'> & {
-        secret: Secret;
-        certificate: Certificate;
-    }>>;
-    single(internalId: ObjectId): Promise<WithId<Omit<Domain, 'secret' | 'certificate'> | SystemDomain>>;
-    /**
-     * @deprecated
-     */
-    createWithSSL(data: ProjectDomain, user: string, app: string): Promise<import("@lilaquadrat/interfaces").CreateResult<BasicData<Domain>>>;
     createWithSecret(data: ProjectDomain, options: Required<UserApp>): Promise<import("@lilaquadrat/interfaces").CreateResult<BasicData<Domain>>>;
-    createWithWildcard(data: SystemDomain, options: Required<UserApp> & {
-        forceFile?: boolean;
-        saveInVault?: boolean;
-    }): Promise<import("@lilaquadrat/interfaces").CreateResult<BasicData<Domain>>>;
-    /**
-     * start a new certification action based upon the last failed for this domain
-     */
-    retrySSL(data: ProjectDomain, user: string, app: string): Promise<null>;
     remove(_id: ObjectId, user: string, app: string): Promise<import("mongodb").DeleteResult>;
-    linkCertificate(certificateInternalId: ObjectId, domain: string, company: string | undefined, project: string | undefined, user: string, app: string): Promise<import("mongodb").UpdateResult<BasicData<Domain>>>;
-    linkMultipleDomains(certificateInternalId: ObjectId, domains: string[], company: string, project: string, user: string, app: string): Promise<import("mongodb").UpdateResult<BasicData<Domain>>[]>;
     /**
      * 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
      */
     validateDnsSecret(domain: string, key: string): Promise<boolean>;
-    /**
-     * 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
-     */
     validateDnsARecord(domain: string, ip: string): Promise<boolean>;
+    validateDnsAAAARecord(domain: string, ip: string): Promise<boolean>;
     getDefaultDomain(company: string, project: string, hostingDomain: string): string;
     getAllDomains(): Promise<WithId<Domain>[]>;
+    /**
+     * 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
+     */
+    getDomainsWithMain(company: string, project: string): Promise<{
+        domains: string[];
+        main?: string;
+    }>;
     createDefaultDomain(company: string, project: string, options: Required<UserApp & {
         baseDomain: string;
     }>): Promise<import("@lilaquadrat/interfaces").CreateResult<BasicData<Domain>> | (import("mongodb").UpdateResult<import("bson").Document> & {
         _id: ObjectId;
     })>;
+    single(internalId: ObjectId, options: Options): Promise<BasicData<ProjectDomain>>;
+    single(internalId: ObjectId, options: Options & {
+        includeSecret: true;
+    }): Promise<BasicData<ProjectDomainWithSecret>>;
     /**
-     * get all domains for specific project with ports and certificates
-     */
-    getDomainsWithPorts(company: string, project: string): Promise<(ProjectDomain & {
-        port: number;
-    })[]>;
-    /**
-     * get all domains from active hosting with ports and certificates
-     */
-    getAllDomainsWithPorts(): Promise<(Hosting & {
-        port: number;
-        domains: ProjectDomain[];
-    })[]>;
-    getCustomQuery(filter: {
-        domain?: string;
-        filterState: string[];
-    }, options: UserAppWithOptions & SkipLimitSort): ListCustomQueries<DomainsList>;
-    /**
-      * add the ports to the domains
-      */
-    mapPortToRealPorts<T>(domains: (T & {
-        ports?: Record<string, number>;
-        port?: number;
-    })[], port: HostingPorts): (T & {
-        ports?: Record<string, number>;
-        port?: number;
-    })[];
-    /**
-     *
-     * map the database format to the working format
-     */
-    mapDomains(domains: (Domain & {
-        port: number;
-    })[]): DomainConf[];
-    /**
-     *
-     * map the database format to the working format
+     * get all active and validated domains for specific project
      */
-    mapDomainsProject(domains: (ProjectDomain & {
-        port: number;
-    })[], options: HostingPorts & {
-        redirectToMainDomain?: boolean;
-    }): {
-        http: DomainConf;
-        https: DomainConf[];
-        defaultDomain?: DomainConf;
-        redirectDomains?: DomainConf[];
-    } | null;
-    requestCertificateForDomain(internalId: ObjectId, options: Required<UserApp>): Promise<null>;
+    getDomains(company: string, project: string): Promise<WithId<Domain>[]>;
 }
 declare const _default: DomainsService;
 export default _default;