@bosunski/laravel-cloud-sdk 0.1.1 → 0.1.4

package/dist/resources/environments.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { createJsonApiCollectionSchema, createJsonApiResponseSchema, JsonApiResourceSchema, } from '../types/jsonApi.js';
 import { deploymentResponseSchema, serializeDeploymentResponse, } from './deployments.js';
+import { keysToCamel } from '../utils/caseConversion.js';
 const colorSchema = z.enum([
     'blue',
     'green',
@@ -55,6 +56,8 @@ const environmentLogsResponseSchema = z.object({
     data: z.array(environmentLogEntrySchema),
     meta: environmentLogMetaSchema,
 });
+// Transform log entry to camelCase
+const transformedLogEntrySchema = environmentLogEntrySchema.transform((data) => keysToCamel(data));
 const environmentAttributesSchema = z
     .object({
     name: z.string(),
@@ -79,33 +82,17 @@ const environmentResourceSchema = JsonApiResourceSchema.extend({
     type: z.literal('environments'),
     attributes: environmentAttributesSchema,
 });
+// Transform resource to camelCase with raw data preserved
+const transformedEnvironmentSchema = environmentResourceSchema.transform((data) => ({
+    ...keysToCamel(data.attributes),
+    id: data.id,
+    raw: data,
+}));
 const environmentResponseSchema = createJsonApiResponseSchema(environmentResourceSchema);
 const environmentCollectionSchema = createJsonApiCollectionSchema(environmentResourceSchema);
+// Simple transformation - schema handles the conversion
 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,
-    };
+    return transformedEnvironmentSchema.parse(resource);
 };
 const serializeEnvironmentList = (response) => ({
     data: response.data.map(mapEnvironment),
@@ -247,13 +234,10 @@ 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,
-});
+// Simple transformation - schema handles the conversion
+const mapEnvironmentLogEntry = (entry) => {
+    return transformedLogEntrySchema.parse(entry);
+};
 export class EnvironmentsResource {
     client;
     constructor(client) {

package/dist/resources/instances.d.ts

@@ -1,13 +1,141 @@
+import { z } from 'zod';
 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 {
+import { JsonApiResponse } from '../types/jsonApi.js';
+declare const transformedInstanceSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodString;
+    relationships: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        data: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>>]>>;
+        links: z.ZodOptional<z.ZodObject<{
+            related: z.ZodOptional<z.ZodObject<{
+                href: z.ZodOptional<z.ZodString>;
+                rel: z.ZodOptional<z.ZodString>;
+                describedby: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                hreflang: z.ZodOptional<z.ZodString>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$loose>>;
+            self: z.ZodOptional<z.ZodObject<{
+                href: z.ZodOptional<z.ZodString>;
+                rel: z.ZodOptional<z.ZodString>;
+                describedby: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                hreflang: z.ZodOptional<z.ZodString>;
+                meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$loose>>>;
+    links: z.ZodOptional<z.ZodObject<{
+        self: z.ZodOptional<z.ZodObject<{
+            href: z.ZodOptional<z.ZodString>;
+            rel: z.ZodOptional<z.ZodString>;
+            describedby: z.ZodOptional<z.ZodString>;
+            title: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            hreflang: z.ZodOptional<z.ZodString>;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$loose>>;
+    }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    type: z.ZodLiteral<"instances">;
+    attributes: z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        size: z.ZodString;
+        scaling_type: z.ZodString;
+        min_replicas: z.ZodNumber;
+        max_replicas: z.ZodNumber;
+        uses_scheduler: z.ZodBoolean;
+        uses_sleep_mode: z.ZodOptional<z.ZodBoolean>;
+        sleep_timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        uses_octane: z.ZodOptional<z.ZodBoolean>;
+        uses_inertia_ssr: z.ZodOptional<z.ZodBoolean>;
+        scaling_cpu_threshold_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        scaling_memory_threshold_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        created_at: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodTransform<{
     id: string;
+    raw: {
+        [x: string]: unknown;
+        id: string;
+        type: "instances";
+        attributes: {
+            [x: string]: unknown;
+            name: string;
+            type: string;
+            size: string;
+            scaling_type: string;
+            min_replicas: number;
+            max_replicas: number;
+            uses_scheduler: boolean;
+            created_at: string;
+            uses_sleep_mode?: boolean | undefined;
+            sleep_timeout?: number | null | undefined;
+            uses_octane?: boolean | undefined;
+            uses_inertia_ssr?: boolean | undefined;
+            scaling_cpu_threshold_percentage?: number | null | undefined;
+            scaling_memory_threshold_percentage?: number | null | undefined;
+        };
+        relationships?: Record<string, {
+            [x: string]: unknown;
+            data?: {
+                type: string;
+                id: string;
+                meta?: Record<string, any> | undefined;
+            } | {
+                type: string;
+                id: string;
+                meta?: Record<string, any> | undefined;
+            }[] | undefined;
+            links?: {
+                related?: {
+                    [x: string]: unknown;
+                    href?: string | undefined;
+                    rel?: string | undefined;
+                    describedby?: string | undefined;
+                    title?: string | undefined;
+                    type?: string | undefined;
+                    hreflang?: string | undefined;
+                    meta?: Record<string, any> | undefined;
+                } | undefined;
+                self?: {
+                    [x: string]: unknown;
+                    href?: string | undefined;
+                    rel?: string | undefined;
+                    describedby?: string | undefined;
+                    title?: string | undefined;
+                    type?: string | undefined;
+                    hreflang?: string | undefined;
+                    meta?: Record<string, any> | undefined;
+                } | undefined;
+            } | undefined;
+            meta?: Record<string, any> | undefined;
+        }> | undefined;
+        links?: {
+            self?: {
+                [x: string]: unknown;
+                href?: string | undefined;
+                rel?: string | undefined;
+                describedby?: string | undefined;
+                title?: string | undefined;
+                type?: string | undefined;
+                hreflang?: string | undefined;
+                meta?: Record<string, any> | undefined;
+            } | undefined;
+        } | undefined;
+        meta?: Record<string, any> | undefined;
+    };
     name: string;
     type: string;
     size: string;
@@ -15,15 +143,91 @@ export interface Instance {
     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;
-}
+    usesSleepMode?: boolean | undefined;
+    sleepTimeout?: number | null | undefined;
+    usesOctane?: boolean | undefined;
+    usesInertiaSsr?: boolean | undefined;
+    scalingCpuThresholdPercentage?: number | null | undefined;
+    scalingMemoryThresholdPercentage?: number | null | undefined;
+}, {
+    [x: string]: unknown;
+    id: string;
+    type: "instances";
+    attributes: {
+        [x: string]: unknown;
+        name: string;
+        type: string;
+        size: string;
+        scaling_type: string;
+        min_replicas: number;
+        max_replicas: number;
+        uses_scheduler: boolean;
+        created_at: string;
+        uses_sleep_mode?: boolean | undefined;
+        sleep_timeout?: number | null | undefined;
+        uses_octane?: boolean | undefined;
+        uses_inertia_ssr?: boolean | undefined;
+        scaling_cpu_threshold_percentage?: number | null | undefined;
+        scaling_memory_threshold_percentage?: number | null | undefined;
+    };
+    relationships?: Record<string, {
+        [x: string]: unknown;
+        data?: {
+            type: string;
+            id: string;
+            meta?: Record<string, any> | undefined;
+        } | {
+            type: string;
+            id: string;
+            meta?: Record<string, any> | undefined;
+        }[] | undefined;
+        links?: {
+            related?: {
+                [x: string]: unknown;
+                href?: string | undefined;
+                rel?: string | undefined;
+                describedby?: string | undefined;
+                title?: string | undefined;
+                type?: string | undefined;
+                hreflang?: string | undefined;
+                meta?: Record<string, any> | undefined;
+            } | undefined;
+            self?: {
+                [x: string]: unknown;
+                href?: string | undefined;
+                rel?: string | undefined;
+                describedby?: string | undefined;
+                title?: string | undefined;
+                type?: string | undefined;
+                hreflang?: string | undefined;
+                meta?: Record<string, any> | undefined;
+            } | undefined;
+        } | undefined;
+        meta?: Record<string, any> | undefined;
+    }> | undefined;
+    links?: {
+        self?: {
+            [x: string]: unknown;
+            href?: string | undefined;
+            rel?: string | undefined;
+            describedby?: string | undefined;
+            title?: string | undefined;
+            type?: string | undefined;
+            hreflang?: string | undefined;
+            meta?: Record<string, any> | undefined;
+        } | undefined;
+    } | undefined;
+    meta?: Record<string, any> | undefined;
+}>>;
+export type Instance = z.infer<typeof transformedInstanceSchema>;
+declare const backgroundProcessSchema: z.ZodObject<{
+    type: z.ZodString;
+    processes: z.ZodNumber;
+    command: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strict>;
+export type InstanceBackgroundProcess = z.infer<typeof backgroundProcessSchema>;
 export interface ListInstancesOptions {
     include?: Array<'environment' | 'backgroundProcesses'>;
     filter?: {
@@ -81,3 +285,4 @@ export declare class InstancesResource {
     update(instanceId: string, payload: UpdateInstancePayload): Promise<InstanceResponse>;
     delete(instanceId: string): Promise<void>;
 }
+export {};

package/dist/resources/instances.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { createJsonApiCollectionSchema, createJsonApiResponseSchema, JsonApiResourceSchema, } from '../types/jsonApi.js';
+import { keysToCamel } from '../utils/caseConversion.js';
 const instanceAttributesSchema = z
     .object({
     name: z.string(),
@@ -22,6 +23,12 @@ const instanceResourceSchema = JsonApiResourceSchema.extend({
     type: z.literal('instances'),
     attributes: instanceAttributesSchema,
 });
+// Transform resource to camelCase with raw data preserved
+const transformedInstanceSchema = instanceResourceSchema.transform((data) => ({
+    ...keysToCamel(data.attributes),
+    id: data.id,
+    raw: data,
+}));
 const instanceResponseSchema = createJsonApiResponseSchema(instanceResourceSchema);
 const instanceCollectionSchema = createJsonApiCollectionSchema(instanceResourceSchema);
 const backgroundProcessSchema = z
@@ -32,27 +39,9 @@ const backgroundProcessSchema = z
     config: z.record(z.string(), z.any()).optional(),
 })
     .strict();
+// Simple transformation - schema handles the conversion
 const mapInstance = (resource) => {
-    const parsed = instanceResourceSchema.parse(resource);
-    const { attributes } = parsed;
-    return {
-        id: parsed.id,
-        name: attributes.name,
-        type: attributes.type,
-        size: attributes.size,
-        scalingType: attributes.scaling_type,
-        minReplicas: attributes.min_replicas,
-        maxReplicas: attributes.max_replicas,
-        usesScheduler: attributes.uses_scheduler,
-        usesSleepMode: attributes.uses_sleep_mode,
-        sleepTimeout: attributes.sleep_timeout ?? null,
-        usesOctane: attributes.uses_octane,
-        usesInertiaSsr: attributes.uses_inertia_ssr,
-        scalingCpuThresholdPercentage: attributes.scaling_cpu_threshold_percentage ?? null,
-        scalingMemoryThresholdPercentage: attributes.scaling_memory_threshold_percentage ?? null,
-        createdAt: attributes.created_at,
-        raw: parsed,
-    };
+    return transformedInstanceSchema.parse(resource);
 };
 const serializeInstanceList = (response) => ({
     data: response.data.map(mapInstance),

package/dist/utils/caseConversion.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Convert a snake_case string to camelCase
+ */
+export declare function snakeToCamel(str: string): string;
+/**
+ * TypeScript utility type to convert snake_case to camelCase at the type level
+ */
+type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : S;
+/**
+ * Convert all keys of an object type from snake_case to camelCase
+ */
+export type KeysToCamelCase<T> = {
+    [K in keyof T as K extends string ? CamelCase<K> : K]: T[K];
+};
+/**
+ * Convert all keys in an object from snake_case to camelCase
+ * Recursively handles nested objects and arrays
+ */
+export declare function keysToCamel<T extends Record<string, unknown>>(obj: T): KeysToCamelCase<T>;
+export {};

package/dist/utils/caseConversion.js

@@ -0,0 +1,35 @@
+/**
+ * Convert a snake_case string to camelCase
+ */
+export function snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/**
+ * Convert all keys in an object from snake_case to camelCase
+ * Recursively handles nested objects and arrays
+ */
+export function keysToCamel(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => typeof item === 'object' && item !== null ? keysToCamel(item) : item);
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const camelKey = snakeToCamel(key);
+        // Recursively convert nested objects and arrays
+        if (value && typeof value === 'object') {
+            if (Array.isArray(value)) {
+                result[camelKey] = value.map((item) => typeof item === 'object' && item !== null ? keysToCamel(item) : item);
+            }
+            else {
+                result[camelKey] = keysToCamel(value);
+            }
+        }
+        else {
+            result[camelKey] = value;
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bosunski/laravel-cloud-sdk",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "TypeScript client for the Laravel Cloud API",
   "type": "module",
   "main": "./dist/index.js",