@bosunski/laravel-cloud-sdk 0.1.1

package/dist/resources/environments.js

@@ -0,0 +1,417 @@
+import { z } from 'zod';
+import { createJsonApiCollectionSchema, createJsonApiResponseSchema, JsonApiResourceSchema, } from '../types/jsonApi.js';
+import { deploymentResponseSchema, serializeDeploymentResponse, } from './deployments.js';
+const colorSchema = z.enum([
+    'blue',
+    'green',
+    'orange',
+    'purple',
+    'red',
+    'yellow',
+    'cyan',
+    'gray',
+]);
+const phpVersionSchema = z.enum(['8.2:1', '8.3:1', '8.4:1', '8.5:1']);
+const nodeVersionSchema = z.enum(['20', '22', '24']);
+const environmentVariableSchema = z.object({
+    key: z.string(),
+    value: z.string().nullable().optional(),
+});
+const filesystemKeySchema = z.object({
+    id: z.string(),
+    disk: z.string(),
+    is_default_disk: z.boolean().optional(),
+});
+const environmentLogDataSchema = z
+    .object({
+    status: z.number().optional(),
+    method: z.string().optional(),
+    path: z.string().optional(),
+    duration_ms: z.number().optional(),
+    bytes_sent: z.number().optional(),
+    ip: z.string().optional(),
+    user_agent: z.string().optional(),
+    country: z.string().optional(),
+})
+    .passthrough();
+const environmentLogEntrySchema = z
+    .object({
+    message: z.string(),
+    level: z.string(),
+    type: z.string(),
+    logged_at: z.string(),
+    data: environmentLogDataSchema.optional(),
+})
+    .passthrough();
+const environmentLogMetaSchema = z
+    .object({
+    cursor: z.string().nullable().optional(),
+    type: z.string().nullable().optional(),
+    from: z.string(),
+    to: z.string(),
+})
+    .passthrough();
+const environmentLogsResponseSchema = z.object({
+    data: z.array(environmentLogEntrySchema),
+    meta: environmentLogMetaSchema,
+});
+const environmentAttributesSchema = z
+    .object({
+    name: z.string(),
+    slug: z.string(),
+    status: z.string(),
+    created_at: z.string(),
+    created_from_automation: z.boolean().optional(),
+    vanity_domain: z.string().nullable().optional(),
+    php_major_version: z.string().optional(),
+    build_command: z.string().nullable().optional(),
+    node_version: z.string().nullable().optional(),
+    deploy_command: z.string().nullable().optional(),
+    uses_octane: z.boolean().optional(),
+    uses_hibernation: z.boolean().optional(),
+    uses_push_to_deploy: z.boolean().optional(),
+    uses_deploy_hook: z.boolean().optional(),
+    environment_variables: z.array(environmentVariableSchema).optional(),
+    network_settings: z.record(z.string(), z.any()).optional(),
+})
+    .passthrough();
+const environmentResourceSchema = JsonApiResourceSchema.extend({
+    type: z.literal('environments'),
+    attributes: environmentAttributesSchema,
+});
+const environmentResponseSchema = createJsonApiResponseSchema(environmentResourceSchema);
+const environmentCollectionSchema = createJsonApiCollectionSchema(environmentResourceSchema);
+const mapEnvironment = (resource) => {
+    const parsed = environmentResourceSchema.parse(resource);
+    const { attributes } = parsed;
+    return {
+        id: parsed.id,
+        name: attributes.name,
+        slug: attributes.slug,
+        status: attributes.status,
+        createdAt: attributes.created_at,
+        createdFromAutomation: attributes.created_from_automation,
+        vanityDomain: attributes.vanity_domain ?? null,
+        phpMajorVersion: attributes.php_major_version,
+        buildCommand: attributes.build_command ?? null,
+        nodeVersion: attributes.node_version ?? null,
+        deployCommand: attributes.deploy_command ?? null,
+        usesOctane: attributes.uses_octane,
+        usesHibernation: attributes.uses_hibernation,
+        usesPushToDeploy: attributes.uses_push_to_deploy,
+        usesDeployHook: attributes.uses_deploy_hook,
+        environmentVariables: attributes.environment_variables?.map((variable) => ({
+            key: variable.key,
+            value: variable.value ?? null,
+        })),
+        raw: parsed,
+    };
+};
+const serializeEnvironmentList = (response) => ({
+    data: response.data.map(mapEnvironment),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+const serializeEnvironmentResponse = (response) => ({
+    data: mapEnvironment(response.data),
+    included: response.included,
+    meta: response.meta,
+    links: response.links,
+});
+const updateEnvironmentSchema = z
+    .object({
+    name: z.string().min(1).max(40).optional(),
+    slug: z.string().min(1).optional(),
+    color: colorSchema.optional(),
+    branch: z.string().optional(),
+    usesPushToDeploy: z.boolean().optional(),
+    usesDeployHook: z.boolean().optional(),
+    timeout: z.number().min(5).max(60).optional(),
+    phpVersion: phpVersionSchema.optional(),
+    buildCommand: z.string().max(2000).nullable().optional(),
+    nodeVersion: nodeVersionSchema.optional(),
+    deployCommand: z.string().max(2000).nullable().optional(),
+    usesVanityDomain: z.boolean().optional(),
+    databaseSchemaId: z.string().nullable().optional(),
+    cacheId: z.string().nullable().optional(),
+    websocketApplicationId: z.string().nullable().optional(),
+    environmentVariables: z
+        .array(z.object({
+        key: z.string(),
+        value: z.string().nullable().optional(),
+    }))
+        .optional(),
+    usesOctane: z.boolean().optional(),
+    sleepTimeout: z.number().optional(),
+    shutdownTimeout: z.number().optional(),
+    usesPurgeEdgeCacheOnDeploy: z.boolean().optional(),
+    nightwatchToken: z.string().nullable().optional(),
+    cacheStrategy: z.string().optional(),
+    responseHeadersFrame: z.string().optional(),
+    responseHeadersContentType: z.string().optional(),
+    responseHeadersRobotsTag: z.string().optional(),
+    responseHeadersHsts: z
+        .object({
+        max_age: z.number(),
+        include_subdomains: z.boolean().optional(),
+        preload: z.boolean().optional(),
+    })
+        .nullable()
+        .optional(),
+    filesystemKeys: z
+        .array(z.object({
+        id: z.string(),
+        disk: z.string(),
+        isDefaultDisk: z.boolean().optional(),
+    }))
+        .optional(),
+    firewallRateLimitLevel: z.enum(['challenge', 'throttle', 'ban']).optional(),
+    firewallUnderAttackMode: z.boolean().optional(),
+})
+    .strict();
+const mapEnvironmentUpdatePayload = (payload) => {
+    const body = {};
+    const assign = (key, value) => {
+        if (value !== undefined) {
+            body[key] = value;
+        }
+    };
+    assign('name', payload.name);
+    assign('slug', payload.slug);
+    assign('color', payload.color);
+    assign('branch', payload.branch);
+    assign('uses_push_to_deploy', payload.usesPushToDeploy);
+    assign('uses_deploy_hook', payload.usesDeployHook);
+    assign('timeout', payload.timeout);
+    assign('php_version', payload.phpVersion);
+    assign('build_command', payload.buildCommand);
+    assign('node_version', payload.nodeVersion);
+    assign('deploy_command', payload.deployCommand);
+    assign('uses_vanity_domain', payload.usesVanityDomain);
+    assign('database_schema_id', payload.databaseSchemaId);
+    assign('cache_id', payload.cacheId);
+    assign('websocket_application_id', payload.websocketApplicationId);
+    assign('environment_variables', payload.environmentVariables);
+    assign('uses_octane', payload.usesOctane);
+    assign('sleep_timeout', payload.sleepTimeout);
+    assign('shutdown_timeout', payload.shutdownTimeout);
+    assign('uses_purge_edge_cache_on_deploy', payload.usesPurgeEdgeCacheOnDeploy);
+    assign('nightwatch_token', payload.nightwatchToken);
+    assign('cache_strategy', payload.cacheStrategy);
+    assign('response_headers_frame', payload.responseHeadersFrame);
+    assign('response_headers_content_type', payload.responseHeadersContentType);
+    assign('response_headers_robots_tag', payload.responseHeadersRobotsTag);
+    assign('response_headers_hsts', payload.responseHeadersHsts);
+    if (payload.filesystemKeys) {
+        body['filesystem_keys'] = payload.filesystemKeys.map((item) => ({
+            id: item.id,
+            disk: item.disk,
+            is_default_disk: item.isDefaultDisk,
+        }));
+    }
+    assign('firewall_rate_limit_level', payload.firewallRateLimitLevel);
+    assign('firewall_under_attack_mode', payload.firewallUnderAttackMode);
+    return body;
+};
+const addEnvironmentVariablesSchema = z.object({
+    method: z.enum(['append', 'set']),
+    variables: z
+        .array(z.object({
+        key: z.string(),
+        value: z.string().nullable().optional(),
+    }))
+        .min(1),
+});
+const replaceEnvironmentVariablesSchema = z
+    .object({
+    content: z.string().nullable().optional(),
+    variables: z
+        .array(z.object({
+        key: z.string(),
+        value: z.string().nullable().optional(),
+    }))
+        .optional(),
+})
+    .superRefine((value, ctx) => {
+    const hasContent = value.content !== undefined && value.content !== null;
+    const hasVariables = value.variables !== undefined;
+    if (hasContent === hasVariables) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Provide either content or variables, but not both.',
+        });
+    }
+});
+const mapVariablesToApi = (variables) => variables.map((variable) => ({
+    key: variable.key,
+    value: variable.value ?? null,
+}));
+const mapEnvironmentLogEntry = (entry) => ({
+    message: entry.message,
+    level: entry.level,
+    type: entry.type,
+    loggedAt: entry.logged_at,
+    data: entry.data ? { ...entry.data } : undefined,
+});
+export class EnvironmentsResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async list(applicationId, 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?.status) {
+            query['filter[status]'] = options.filter.status;
+        }
+        if (options?.filter?.slug) {
+            query['filter[slug]'] = options.filter.slug;
+        }
+        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: `/applications/${applicationId}/environments`,
+            method: 'GET',
+            query,
+            schema: environmentCollectionSchema,
+        });
+        return serializeEnvironmentList(response);
+    }
+    async retrieve(environmentId, options) {
+        const query = options?.include?.length
+            ? { include: options.include.join(',') }
+            : undefined;
+        const response = await this.client.request({
+            path: `/environments/${environmentId}`,
+            method: 'GET',
+            query,
+            schema: environmentResponseSchema,
+        });
+        return serializeEnvironmentResponse(response);
+    }
+    async create(applicationId, payload) {
+        const parsedPayload = z
+            .object({
+            branch: z.string().min(1),
+            name: z.string().min(1).max(40),
+        })
+            .parse(payload);
+        const response = await this.client.request({
+            path: `/applications/${applicationId}/environments`,
+            method: 'POST',
+            json: parsedPayload,
+            schema: environmentResponseSchema,
+        });
+        return serializeEnvironmentResponse(response);
+    }
+    async update(environmentId, payload) {
+        const parsedPayload = updateEnvironmentSchema.parse(payload);
+        const body = mapEnvironmentUpdatePayload(parsedPayload);
+        const response = await this.client.request({
+            path: `/environments/${environmentId}`,
+            method: 'PATCH',
+            json: body,
+            schema: environmentResponseSchema,
+        });
+        return serializeEnvironmentResponse(response);
+    }
+    async delete(environmentId) {
+        await this.client.request({
+            path: `/environments/${environmentId}`,
+            method: 'DELETE',
+        });
+    }
+    async start(environmentId, options) {
+        const body = options?.redeploy !== undefined ? { redeploy: options.redeploy } : undefined;
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/start`,
+            method: 'POST',
+            json: body,
+            schema: deploymentResponseSchema,
+        });
+        return serializeDeploymentResponse(response);
+    }
+    async stop(environmentId) {
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/stop`,
+            method: 'POST',
+            schema: environmentResponseSchema,
+        });
+        return serializeEnvironmentResponse(response);
+    }
+    async addVariables(environmentId, payload) {
+        const parsedPayload = addEnvironmentVariablesSchema.parse(payload);
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/variables`,
+            method: 'POST',
+            json: {
+                method: parsedPayload.method,
+                variables: mapVariablesToApi(parsedPayload.variables),
+            },
+            schema: environmentResponseSchema,
+        });
+        return serializeEnvironmentResponse(response);
+    }
+    async replaceVariables(environmentId, payload) {
+        const parsedPayload = replaceEnvironmentVariablesSchema.parse(payload);
+        const body = {};
+        if (parsedPayload.content !== undefined && parsedPayload.content !== null) {
+            body.content = parsedPayload.content;
+        }
+        if (parsedPayload.variables) {
+            body.variables = mapVariablesToApi(parsedPayload.variables);
+        }
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/variables`,
+            method: 'PUT',
+            json: body,
+            schema: environmentResponseSchema,
+        });
+        return serializeEnvironmentResponse(response);
+    }
+    async listLogs(environmentId, options) {
+        const parsedOptions = z
+            .object({
+            from: z.string().min(1),
+            to: z.string().min(1),
+            query: z.string().optional(),
+            type: z.enum(['all', 'application', 'access']).optional(),
+            cursor: z.string().optional(),
+        })
+            .parse(options);
+        const query = {
+            from: parsedOptions.from,
+            to: parsedOptions.to,
+        };
+        if (parsedOptions.query) {
+            query.query = parsedOptions.query;
+        }
+        if (parsedOptions.type) {
+            query.type = parsedOptions.type;
+        }
+        if (parsedOptions.cursor) {
+            query.cursor = parsedOptions.cursor;
+        }
+        const response = await this.client.request({
+            path: `/environments/${environmentId}/logs`,
+            method: 'GET',
+            query,
+            schema: environmentLogsResponseSchema,
+            accept: 'application/json',
+        });
+        return {
+            data: response.data.map(mapEnvironmentLogEntry),
+            meta: response.meta,
+        };
+    }
+}

package/dist/resources/instances.d.ts

@@ -0,0 +1,83 @@
+import { HttpClient } from '../http/client.js';
+import { JsonApiResponse, JsonApiResource } from '../types/jsonApi.js';
+export interface InstanceBackgroundProcess {
+    type: string;
+    processes: number;
+    command?: string;
+    config?: Record<string, unknown>;
+}
+export interface Instance {
+    id: string;
+    name: string;
+    type: string;
+    size: string;
+    scalingType: string;
+    minReplicas: number;
+    maxReplicas: number;
+    usesScheduler: boolean;
+    usesSleepMode?: boolean;
+    sleepTimeout?: number | null;
+    usesOctane?: boolean;
+    usesInertiaSsr?: boolean;
+    scalingCpuThresholdPercentage?: number | null;
+    scalingMemoryThresholdPercentage?: number | null;
+    createdAt: string;
+    raw: JsonApiResource;
+}
+export interface ListInstancesOptions {
+    include?: Array<'environment' | 'backgroundProcesses'>;
+    filter?: {
+        name?: string;
+        type?: string;
+        size?: string;
+        scalingType?: string;
+    };
+    page?: {
+        number?: number;
+        size?: number;
+    };
+}
+export interface CreateInstancePayload {
+    name: string;
+    type: string;
+    size: string;
+    scalingType: string;
+    maxReplicas: number;
+    minReplicas: number;
+    usesScheduler: boolean;
+    usesSleepMode?: boolean;
+    sleepTimeout?: number;
+    usesOctane?: boolean;
+    usesInertiaSsr?: boolean;
+    scalingCpuThresholdPercentage?: number | null;
+    scalingMemoryThresholdPercentage?: number | null;
+    backgroundProcesses?: InstanceBackgroundProcess[];
+}
+export interface UpdateInstancePayload {
+    name?: string;
+    size?: string;
+    scalingType?: string;
+    maxReplicas?: number;
+    minReplicas?: number;
+    usesScheduler?: boolean;
+    usesSleepMode?: boolean;
+    sleepTimeout?: number;
+    usesOctane?: boolean;
+    usesInertiaSsr?: boolean;
+    scalingCpuThresholdPercentage?: number | null;
+    scalingMemoryThresholdPercentage?: number | null;
+    backgroundProcesses?: InstanceBackgroundProcess[];
+}
+export interface InstanceListResponse extends JsonApiResponse<Instance[]> {
+}
+export interface InstanceResponse extends JsonApiResponse<Instance> {
+}
+export declare class InstancesResource {
+    private readonly client;
+    constructor(client: HttpClient);
+    list(environmentId: string, options?: ListInstancesOptions): Promise<InstanceListResponse>;
+    create(environmentId: string, payload: CreateInstancePayload): Promise<InstanceResponse>;
+    retrieve(instanceId: string, options?: Pick<ListInstancesOptions, 'include'>): Promise<InstanceResponse>;
+    update(instanceId: string, payload: UpdateInstancePayload): Promise<InstanceResponse>;
+    delete(instanceId: string): Promise<void>;
+}