@bosunski/laravel-cloud-sdk 0.1.1

package/dist/resources/domains.js

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+import { createJsonApiCollectionSchema, createJsonApiResponseSchema, JsonApiResourceSchema, } from '../types/jsonApi.js';
+const domainVerificationMethodSchema = z.enum([
+    'pre_verification',
+    'real_time',
+]);
+const domainRedirectSchema = z.enum(['root_to_www', 'www_to_root']);
+const domainAttributesSchema = z
+    .object({
+    name: z.string(),
+    type: z.string(),
+    hostname_status: z.string(),
+    ssl_status: z.string(),
+    origin_status: z.string(),
+    redirect: z.string().nullable().optional(),
+    dns_records: z.record(z.string(), z.any()).optional(),
+    wildcard: z.record(z.string(), z.any()).optional(),
+    www: z.record(z.string(), z.any()).optional(),
+    last_verified_at: z.string().nullable().optional(),
+    created_at: z.string(),
+})
+    .passthrough();
+const domainResourceSchema = JsonApiResourceSchema.extend({
+    type: z.literal('domains'),
+    attributes: domainAttributesSchema,
+});
+const domainResponseSchema = createJsonApiResponseSchema(domainResourceSchema);
+const domainCollectionSchema = createJsonApiCollectionSchema(domainResourceSchema);
+const mapDomain = (resource) => {
+    const parsed = domainResourceSchema.parse(resource);
+    const { attributes } = parsed;
+    return {
+        id: parsed.id,
+        name: attributes.name,
+        type: attributes.type,
+        hostnameStatus: attributes.hostname_status,
+        sslStatus: attributes.ssl_status,
+        originStatus: attributes.origin_status,
+        redirect: attributes.redirect ?? null,
+        lastVerifiedAt: attributes.last_verified_at ?? null,
+        createdAt: attributes.created_at,
+        dnsRecords: attributes.dns_records,
+        wildcard: attributes.wildcard,
+        www: attributes.www,
+        raw: parsed,
+    };
+};
+const serializeDomainList = (response) => ({
+    data: response.data.map(mapDomain),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+const serializeDomainResponse = (response) => ({
+    data: mapDomain(response.data),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+const createDomainSchema = z.object({
+    name: z.string().min(3).max(255),
+    wwwRedirect: domainRedirectSchema.nullable().optional(),
+    wildcardEnabled: z.boolean().optional(),
+    verificationMethod: domainVerificationMethodSchema.optional(),
+});
+const updateDomainSchema = z
+    .object({
+    verificationMethod: domainVerificationMethodSchema.optional(),
+})
+    .strict();
+export class DomainsResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async list(environmentId, options) {
+        const query = {};
+        if (options?.include?.length) {
+            query.include = options.include.join(',');
+        }
+        if (options?.filter?.name) {
+            query['filter[name]'] = options.filter.name;
+        }
+        if (options?.filter?.hostnameStatus) {
+            query['filter[hostname_status]'] = options.filter.hostnameStatus;
+        }
+        if (options?.filter?.sslStatus) {
+            query['filter[ssl_status]'] = options.filter.sslStatus;
+        }
+        if (options?.filter?.originStatus) {
+            query['filter[origin_status]'] = options.filter.originStatus;
+        }
+        if (options?.page?.number !== undefined) {
+            query['page[number]'] = options.page.number;
+        }
+        if (options?.page?.size !== undefined) {
+            query['page[size]'] = options.page.size;
+        }
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/domains`,
+            method: 'GET',
+            query,
+            schema: domainCollectionSchema,
+        });
+        return serializeDomainList(response);
+    }
+    async create(environmentId, payload) {
+        const parsedPayload = createDomainSchema.parse(payload);
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/domains`,
+            method: 'POST',
+            json: {
+                name: parsedPayload.name,
+                www_redirect: parsedPayload.wwwRedirect ?? undefined,
+                wildcard_enabled: parsedPayload.wildcardEnabled,
+                verification_method: parsedPayload.verificationMethod,
+            },
+            schema: domainResponseSchema,
+        });
+        return serializeDomainResponse(response);
+    }
+    async retrieve(domainId, options) {
+        const query = {};
+        if (options?.include?.length) {
+            query.include = options.include.join(',');
+        }
+        if (options?.verify !== undefined) {
+            query.verify = String(options.verify);
+        }
+        const response = await this.client.request({
+            path: `/domains/${domainId}`,
+            method: 'GET',
+            query: Object.keys(query).length ? query : undefined,
+            schema: domainResponseSchema,
+        });
+        return serializeDomainResponse(response);
+    }
+    async update(domainId, payload) {
+        const parsedPayload = updateDomainSchema.parse(payload);
+        const response = await this.client.request({
+            path: `/domains/${domainId}`,
+            method: 'PATCH',
+            json: {
+                verification_method: parsedPayload.verificationMethod,
+            },
+            schema: domainResponseSchema,
+        });
+        return serializeDomainResponse(response);
+    }
+    async verify(domainId) {
+        const response = await this.client.request({
+            path: `/domains/${domainId}/verify`,
+            method: 'POST',
+            schema: domainResponseSchema,
+        });
+        return serializeDomainResponse(response);
+    }
+    async delete(domainId) {
+        await this.client.request({
+            path: `/domains/${domainId}`,
+            method: 'DELETE',
+        });
+    }
+}

package/dist/resources/environments.d.ts

@@ -0,0 +1,159 @@
+import { z } from 'zod';
+import { HttpClient } from '../http/client.js';
+import { JsonApiResponse, JsonApiResource } from '../types/jsonApi.js';
+import type { DeploymentResponse } from './deployments.js';
+declare const colorSchema: z.ZodEnum<{
+    blue: "blue";
+    green: "green";
+    orange: "orange";
+    purple: "purple";
+    red: "red";
+    yellow: "yellow";
+    cyan: "cyan";
+    gray: "gray";
+}>;
+declare const phpVersionSchema: z.ZodEnum<{
+    "8.2:1": "8.2:1";
+    "8.3:1": "8.3:1";
+    "8.4:1": "8.4:1";
+    "8.5:1": "8.5:1";
+}>;
+declare const nodeVersionSchema: z.ZodEnum<{
+    20: "20";
+    22: "22";
+    24: "24";
+}>;
+export interface EnvironmentVariable {
+    key: string;
+    value?: string | null;
+}
+export interface FilesystemKey {
+    id: string;
+    disk: string;
+    isDefaultDisk?: boolean;
+}
+export interface Environment {
+    id: string;
+    name: string;
+    slug: string;
+    status: string;
+    createdAt: string;
+    createdFromAutomation?: boolean;
+    vanityDomain?: string | null;
+    phpMajorVersion?: string;
+    buildCommand?: string | null;
+    nodeVersion?: string | null;
+    deployCommand?: string | null;
+    usesOctane?: boolean;
+    usesHibernation?: boolean;
+    usesPushToDeploy?: boolean;
+    usesDeployHook?: boolean;
+    environmentVariables?: EnvironmentVariable[];
+    raw: JsonApiResource;
+}
+export interface ListEnvironmentsOptions {
+    include?: Array<'application' | 'branch' | 'deployments' | 'currentDeployment' | 'primaryDomain' | 'instances'>;
+    filter?: {
+        name?: string;
+        status?: string;
+        slug?: string;
+    };
+    page?: {
+        number?: number;
+        size?: number;
+    };
+}
+export interface CreateEnvironmentPayload {
+    branch: string;
+    name: string;
+}
+export interface UpdateEnvironmentPayload {
+    name?: string;
+    slug?: string;
+    color?: z.infer<typeof colorSchema>;
+    branch?: string;
+    usesPushToDeploy?: boolean;
+    usesDeployHook?: boolean;
+    timeout?: number;
+    phpVersion?: z.infer<typeof phpVersionSchema>;
+    buildCommand?: string | null;
+    nodeVersion?: z.infer<typeof nodeVersionSchema>;
+    deployCommand?: string | null;
+    usesVanityDomain?: boolean;
+    databaseSchemaId?: string | null;
+    cacheId?: string | null;
+    websocketApplicationId?: string | null;
+    environmentVariables?: EnvironmentVariable[];
+    usesOctane?: boolean;
+    sleepTimeout?: number;
+    shutdownTimeout?: number;
+    usesPurgeEdgeCacheOnDeploy?: boolean;
+    nightwatchToken?: string | null;
+    cacheStrategy?: string;
+    responseHeadersFrame?: string;
+    responseHeadersContentType?: string;
+    responseHeadersRobotsTag?: string;
+    responseHeadersHsts?: {
+        max_age: number;
+        include_subdomains?: boolean;
+        preload?: boolean;
+    } | null;
+    filesystemKeys?: Array<Omit<FilesystemKey, 'isDefaultDisk'> & {
+        isDefaultDisk?: boolean;
+    }>;
+    firewallRateLimitLevel?: 'challenge' | 'throttle' | 'ban';
+    firewallUnderAttackMode?: boolean;
+}
+export interface StartEnvironmentOptions {
+    redeploy?: boolean;
+}
+export interface AddEnvironmentVariablesPayload {
+    method: 'append' | 'set';
+    variables: EnvironmentVariable[];
+}
+export interface ReplaceEnvironmentVariablesPayload {
+    content?: string | null;
+    variables?: EnvironmentVariable[];
+}
+export interface ListEnvironmentLogsOptions {
+    from: string;
+    to: string;
+    query?: string;
+    type?: 'all' | 'application' | 'access';
+    cursor?: string;
+}
+export interface EnvironmentLogEntry {
+    message: string;
+    level: string;
+    type: string;
+    loggedAt: string;
+    data?: Record<string, unknown>;
+}
+export interface EnvironmentLogsResponse {
+    data: EnvironmentLogEntry[];
+    meta: Record<string, unknown> & {
+        cursor?: string | null;
+        type?: string | null;
+        from: string;
+        to: string;
+    };
+}
+export interface EnvironmentListResponse extends JsonApiResponse<Environment[]> {
+}
+export interface EnvironmentResponse extends JsonApiResponse<Environment> {
+}
+export declare class EnvironmentsResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    list(applicationId: string, options?: ListEnvironmentsOptions): Promise<EnvironmentListResponse>;
+    retrieve(environmentId: string, options?: Pick<ListEnvironmentsOptions, 'include'>): Promise<EnvironmentResponse>;
+    create(applicationId: string, payload: CreateEnvironmentPayload): Promise<EnvironmentResponse>;
+    update(environmentId: string, payload: UpdateEnvironmentPayload): Promise<EnvironmentResponse>;
+    delete(environmentId: string): Promise<void>;
+    start(environmentId: string, options?: StartEnvironmentOptions): Promise<DeploymentResponse>;
+    stop(environmentId: string): Promise<EnvironmentResponse>;
+    addVariables(environmentId: string, payload: AddEnvironmentVariablesPayload): Promise<EnvironmentResponse>;
+    replaceVariables(environmentId: string, payload: ReplaceEnvironmentVariablesPayload): Promise<EnvironmentResponse>;
+    listLogs(environmentId: string, options: ListEnvironmentLogsOptions): Promise<EnvironmentLogsResponse>;
+}
+export {};