eclesiar-sdk 1.1.0 → 1.1.3

package/dist/api/wars/index.js

@@ -0,0 +1,9 @@
+import { getWars } from './getWars';
+import { getWarRounds } from './getWarRounds';
+import { getWarRoundHits } from './getWarRoundHits';
+export const warsApi = {
+    getWars,
+    getWarRounds,
+    getWarRoundHits,
+};
+export { getWars, getWarRounds, getWarRoundHits, };

package/dist/api/wars/types.d.ts

@@ -0,0 +1,10 @@
+import { WarRound, WarHit, War, GetWarsParams } from "../../types";
+export interface WarsApi {
+    getWars(params: GetWarsParams): Promise<War[]>;
+    getWarRounds({ war_id }: {
+        war_id: number;
+    }): Promise<WarRound[]>;
+    getWarRoundHits({ war_round_id }: {
+        war_round_id: number;
+    }): Promise<WarHit[]>;
+}

package/dist/api/wars/types.js

@@ -0,0 +1 @@
+export {};

package/dist/client copy.d.ts

@@ -0,0 +1,25 @@
+import type { AccountsApi } from './api/accounts/types';
+import type { CountriesApi } from './api/countries/types';
+import type { MarketApi } from './api/market/types';
+import type { ServerApi } from './api/server/types';
+import type { StatisticsApi } from './api/statistics/types';
+import type { WarsApi } from './api/wars/types';
+export declare function setToken(token: string): void;
+export interface SdkClient {
+    accounts: AccountsApi;
+    countries: CountriesApi;
+    market: MarketApi;
+    server: ServerApi;
+    statistics: StatisticsApi;
+    wars: WarsApi;
+    config: {
+        token: string | null;
+        baseUrl: 'https://api.eclesiar.com' | 'https://tests.eclesiar.com';
+    };
+}
+export declare const apiClient: SdkClient;
+export declare function updateConfig(newConfig: {
+    token?: string;
+    baseUrl?: 'https://api.eclesiar.com' | 'https://tests.eclesiar.com';
+}): SdkClient | undefined;
+export declare function apiFetch<T>(endpoint: string, options?: RequestInit): Promise<T>;

package/dist/client copy.js

@@ -0,0 +1,71 @@
+import { accountsApi } from './api/accounts';
+import { countriesApi } from './api/countries';
+import { marketApi } from './api/market';
+import { serverApi } from './api/server';
+import { statisticsApi } from './api/statistics';
+import { warsApi } from './api/wars';
+import { ApiError } from './ApiError';
+let BASE_URL = 'https://api.eclesiar.com';
+export function setToken(token) {
+    updateConfig({ token });
+}
+export const apiClient = {
+    accounts: accountsApi,
+    countries: countriesApi,
+    market: marketApi,
+    server: serverApi,
+    statistics: statisticsApi,
+    wars: warsApi,
+    config: {
+        token: null,
+        baseUrl: BASE_URL,
+    },
+};
+export function updateConfig(newConfig) {
+    if (newConfig.token) {
+        apiClient.config.token = newConfig.token;
+    }
+    if (newConfig.baseUrl) {
+        apiClient.config.baseUrl = newConfig.baseUrl;
+    }
+    if (apiClient.config.token && apiClient.config.baseUrl) {
+        return apiClient;
+    }
+    if (!apiClient.config.token && !apiClient.config.baseUrl) {
+        throw new Error('Config not complete: missing token and baseUrl.');
+    }
+    else if (!apiClient.config.token) {
+        throw new Error('Config not complete: missing token.');
+    }
+    else if (!apiClient.config.baseUrl) {
+        throw new Error('Config not complete: missing baseUrl.');
+    }
+}
+export async function apiFetch(endpoint, options = {}) {
+    if (!apiClient.config.token) {
+        throw new Error('No token provided');
+    }
+    if (!apiClient.config.baseUrl) {
+        throw new Error('No baseUrl provided');
+    }
+    const res = await fetch(`${apiClient.config.baseUrl}${endpoint}`, {
+        ...options,
+        headers: {
+            Authorization: `Bearer ${apiClient.config.token}`,
+            ...(options.headers || {}),
+        },
+    });
+    if (!res.ok) {
+        throw new ApiError(res.status, res.statusText, endpoint, await res.json());
+    }
+    const json = await res.json();
+    // This is a bit of a ugly fix. API returns undefined for no results instead of an empty array. 
+    // Didnt wanna throw an error for this, so i just cast it to an empty array.
+    // Keep in mind, this api might change in the future, so this might break
+    // Also, this does not seem to be making a difference in out of bounds params, and things thats not found
+    if (json.code === 200 && json.data === undefined) {
+        json.data = [];
+    }
+    console.log({ 'API FROM SERVER:': json });
+    return json.data;
+}

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+import type { AccountsApi } from './api/accounts/types';
+import type { CountriesApi } from './api/countries/types';
+import type { MarketApi } from './api/market/types';
+import type { ServerApi } from './api/server/types';
+import type { StatisticsApi } from './api/statistics/types';
+import type { WarsApi } from './api/wars/types';
+export declare function setToken(newToken: string): void;
+export declare function apiFetch<T>(endpoint: string, options?: RequestInit): Promise<T>;
+export interface SdkClient {
+    accounts: AccountsApi;
+    countries: CountriesApi;
+    market: MarketApi;
+    server: ServerApi;
+    statistics: StatisticsApi;
+    wars: WarsApi;
+}
+export declare const apiClient: SdkClient;

package/dist/client.js

@@ -0,0 +1,33 @@
+import { accountsApi } from './api/accounts';
+import { countriesApi } from './api/countries';
+import { marketApi } from './api/market';
+import { serverApi } from './api/server';
+import { statisticsApi } from './api/statistics';
+import { warsApi } from './api/wars';
+const BASE_URL = 'https://api.eclesiar.com';
+let token = '';
+export function setToken(newToken) {
+    token = newToken;
+}
+export async function apiFetch(endpoint, options = {}) {
+    const res = await fetch(`${BASE_URL}${endpoint}`, {
+        ...options,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            ...(options.headers || {}),
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`API Error: ${res.status} ${res.statusText} ${endpoint}`);
+    }
+    const json = await res.json();
+    return json.data;
+}
+export const apiClient = {
+    accounts: accountsApi,
+    countries: countriesApi,
+    market: marketApi,
+    server: serverApi,
+    statistics: statisticsApi,
+    wars: warsApi,
+};

package/dist/config/index.d.ts

@@ -0,0 +1,23 @@
+import { EnvConfig } from "./types/types";
+type KeysWithFallbackValue = "hideTokenOnAllEnvs" | "defaultEnv" | "environments";
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type RequiredConfig = Optional<EnvConfig, KeysWithFallbackValue>;
+/**
+ * Defines the configuration for the SDK.
+ *
+ * This function merges user-provided configuration with defaults.
+ * It ensures that required fields are populated and applies fallback behavior,
+ * especially for token visibility.
+ *
+ * ### Token Visibility Behavior:
+ * - If `hideTokenOnAllEnvs` is set to `true`, then `hideToken: true` will be
+ *   **enforced on all environments**, overriding any `hideToken` values defined
+ *   in the environment-specific configuration.
+ * - If `hideTokenOnAllEnvs` is `false`, each environment's own `hideToken` setting
+ *   will be respected as provided.
+ *
+ * @param {RequiredConfig} config - Partial user configuration.
+ * @returns {EnvConfig} Fully resolved configuration with all necessary defaults applied.
+ */
+export declare function defineConfig(config: RequiredConfig): EnvConfig;
+export {};

package/dist/config/index.js

@@ -0,0 +1,54 @@
+/**
+ * The default configuration used if certain values are not explicitly provided
+ * by the user when calling `defineConfig`.
+ */
+const defaultConfig = {
+    hideTokenOnAllEnvs: true,
+    defaultEnv: "prod",
+    environments: {
+        prod: {
+            baseUrl: "https://api.eclesiar.com",
+            token: null,
+            hideToken: true,
+        },
+        test: {
+            baseUrl: "https://tests-api.eclesiar.com",
+            token: null,
+            hideToken: true,
+        },
+    },
+};
+/**
+ * Defines the configuration for the SDK.
+ *
+ * This function merges user-provided configuration with defaults.
+ * It ensures that required fields are populated and applies fallback behavior,
+ * especially for token visibility.
+ *
+ * ### Token Visibility Behavior:
+ * - If `hideTokenOnAllEnvs` is set to `true`, then `hideToken: true` will be
+ *   **enforced on all environments**, overriding any `hideToken` values defined
+ *   in the environment-specific configuration.
+ * - If `hideTokenOnAllEnvs` is `false`, each environment's own `hideToken` setting
+ *   will be respected as provided.
+ *
+ * @param {RequiredConfig} config - Partial user configuration.
+ * @returns {EnvConfig} Fully resolved configuration with all necessary defaults applied.
+ */
+export function defineConfig(config) {
+    const merged = {
+        ...defaultConfig,
+        ...config,
+        environments: {
+            ...defaultConfig.environments,
+            ...config.environments,
+        },
+    };
+    if (merged.hideTokenOnAllEnvs) {
+        for (const env of Object.values(merged.environments)) {
+            env.hideToken = true;
+        }
+    }
+    return merged;
+}
+// export const config = defineConfig(defaultConfig);

package/dist/config/initConfigFile.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/initConfigFile.js

@@ -0,0 +1,120 @@
+import fs from 'fs';
+import path from 'path';
+import prompts from 'prompts';
+/**
+ * Initializes an interactive CLI session to generate `.eclesiar.config.ts`
+ * and optionally a `.env` file with placeholder or user-provided API tokens.
+ */
+async function initInteractiveConfig() {
+    const targetPath = path.resolve(process.cwd(), '.eclesiar.config.ts');
+    const envPath = path.resolve(process.cwd(), '.env');
+    // Check if config already exists
+    if (fs.existsSync(targetPath)) {
+        const { overwrite } = await prompts({
+            type: 'confirm',
+            name: 'overwrite',
+            message: '.eclesiar.config.ts already exists. Overwrite?',
+            initial: false,
+        });
+        if (!overwrite) {
+            console.log('❌ Aborted.');
+            process.exit(0);
+        }
+    }
+    // Prompt for config options
+    const response = await prompts([
+        {
+            type: 'select',
+            name: 'defaultEnv',
+            message: 'Select default environment:',
+            choices: [
+                { title: 'Production', value: 'prod' },
+                { title: 'Test', value: 'test' },
+            ],
+            initial: 0,
+        },
+        {
+            type: 'confirm',
+            name: 'hideTokenOnAllEnvs',
+            message: 'Hide API tokens by default?',
+            initial: true,
+        },
+        {
+            type: 'confirm',
+            name: 'generateEnv',
+            message: 'Generate a .env file with placeholder keys?',
+            initial: true,
+        }
+    ]);
+    // Defaults for token values
+    let prodToken = '';
+    let testToken = '';
+    // If .env generation selected, prompt for optional token values
+    if (response.generateEnv) {
+        console.log('\n🔐 Enter API tokens for autofill (leave blank to use placeholders):');
+        const tokenResponse = await prompts([
+            {
+                type: 'text',
+                name: 'prodToken',
+                message: 'Production token:',
+            },
+            {
+                type: 'text',
+                name: 'testToken',
+                message: 'Test token:',
+            },
+        ]);
+        prodToken = tokenResponse.prodToken?.trim() || '';
+        testToken = tokenResponse.testToken?.trim() || '';
+    }
+    // Generate config file content
+    const configContent = `import { defineConfig } from 'eclesiar-sdk';
+
+export default defineConfig({
+  hideTokenOnAllEnvs: ${response.hideTokenOnAllEnvs},
+  defaultEnv: '${response.defaultEnv}',
+  environments: {
+    prod: {
+      baseUrl: 'https://api.eclesiar.com',
+      token: ${response.generateEnv ? `'${prodToken}'` : 'process.env.ECLESIAR_PROD_TOKEN'} || null,
+      hideToken: ${response.hideTokenOnAllEnvs},
+    },
+    test: {
+      baseUrl: 'https://tests-api.eclesiar.com',
+      token: ${response.generateEnv ? `'${testToken}'` : 'process.env.ECLESIAR_TEST_TOKEN'} || null,
+      hideToken: ${response.hideTokenOnAllEnvs},
+    },
+  },
+});
+`;
+    fs.writeFileSync(targetPath, configContent);
+    console.log(`✅ Created: ${targetPath}`);
+    // Optionally write .env file
+    if (response.generateEnv && !fs.existsSync(envPath)) {
+        const envTemplate = `# Eclesiar API Tokens
+ECLESIAR_PROD_TOKEN=${prodToken || 'your-prod-token-here'}
+ECLESIAR_TEST_TOKEN=${testToken || 'your-test-token-here'}
+`;
+        fs.writeFileSync(envPath, envTemplate);
+        console.log(`✅ Created: ${envPath}`);
+        console.log('⚠️  Reminder: Do not commit .env files to version control!');
+        const isGitignoreExists = fs.existsSync('.gitignore');
+        if (!isGitignoreExists) {
+            fs.writeFileSync('.gitignore', '.env');
+            console.log('✅ Created: .gitignore');
+        }
+    }
+    else if (fs.existsSync(envPath)) {
+        console.log('⚠️  Skipped .env generation: file already exists.');
+    }
+    console.log('\n🎉 Configuration complete.\n');
+    process.exit(0);
+}
+/**
+ * Checks for the `--create-config-file` flag and runs the interactive config init.
+ */
+async function handleCreateConfigFlag() {
+    if (process.argv.includes('--create-config-file')) {
+        await initInteractiveConfig();
+    }
+}

package/dist/config/types/configSchema.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+declare const EnvConfigSchema: z.ZodObject<{
+    defaultEnv: z.ZodUnion<readonly [z.ZodLiteral<"prod">, z.ZodLiteral<"test">]>;
+    hideTokenOnAllEnvs: z.ZodBoolean;
+    environments: z.ZodObject<{
+        prod: z.ZodObject<{
+            baseUrl: z.ZodString;
+            token: z.ZodOptional<z.ZodString>;
+            hideToken: z.ZodBoolean;
+        }, z.core.$strip>;
+        test: z.ZodObject<{
+            baseUrl: z.ZodString;
+            token: z.ZodOptional<z.ZodString>;
+            hideToken: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EnvConfig = z.infer<typeof EnvConfigSchema>;
+export {};

package/dist/config/types/configSchema.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+const EnvironmentSchema = z.object({
+    baseUrl: z.string().url(),
+    token: z.string().optional(),
+    hideToken: z.boolean(),
+});
+const EnvConfigSchema = z.object({
+    defaultEnv: z.union([z.literal("prod"), z.literal("test")]),
+    hideTokenOnAllEnvs: z.boolean(),
+    environments: z.object({
+        prod: EnvironmentSchema,
+        test: EnvironmentSchema,
+    }),
+});

package/dist/config/types/types.d.ts

@@ -0,0 +1,19 @@
+export interface EnvConfig {
+    environments: Enviroments;
+    defaultEnv: 'prod' | 'test';
+    hideTokenOnAllEnvs?: boolean;
+}
+type Enviroments = {
+    prod: {
+        baseUrl: string;
+        token: string | null;
+        hideToken?: boolean;
+    };
+    test: {
+        baseUrl: string;
+        token: string | null;
+        hideToken?: boolean;
+    };
+};
+export type Enviroment = Enviroments['prod'] | Enviroments['test'];
+export {};

package/dist/config/types/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+export declare const config: Promise<{
+    defaultEnv: "prod" | "test";
+    hideTokenOnAllEnvs: boolean;
+    environments: {
+        prod: {
+            baseUrl: string;
+            hideToken: boolean;
+            token?: string | undefined;
+        };
+        test: {
+            baseUrl: string;
+            hideToken: boolean;
+            token?: string | undefined;
+        };
+    };
+}>;

package/dist/config.js

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import path from 'path';
+const defaultConfig = {
+    environments: {
+        prod: {
+            baseUrl: 'https://api.eclesiar.com',
+            token: undefined,
+            hideToken: true,
+        },
+        test: {
+            baseUrl: 'https://tests-api.eclesiar.com',
+            token: undefined,
+            hideToken: true,
+        },
+    },
+    defaultEnv: 'prod',
+    hideTokenOnAllEnvs: true,
+};
+async function loadConfig() {
+    const envPath = process.env.ECLESIAR_CONFIG;
+    const probable_paths = [
+        './.eclesiar.config.ts',
+        './eclesiar.config.js',
+        './eclesiar.config.ts'
+    ];
+    let configPath = path.resolve(process.cwd() || envPath || probable_paths.find((p) => fs.existsSync(p)) || '');
+    if (!configPath.endsWith('.ts') && !configPath.endsWith('.js')) {
+        console.warn(`[Eclesiar SDK] Config file must end with .ts or .js: ${configPath}`);
+        return defaultConfig;
+    }
+    if (!fs.existsSync(configPath) || !fs.lstatSync(configPath).isFile()) {
+        console.warn(`[Eclesiar SDK] Config file not found: ${configPath}`);
+        return defaultConfig;
+    }
+    try {
+        const module = await import(configPath);
+        console.log(`[Eclesiar SDK] Using config file: ${configPath}`);
+        return module.default || module;
+    }
+    catch (err) {
+        console.warn(`[Eclesiar SDK] Failed to import config file: ${configPath}`);
+        console.warn(err);
+        return defaultConfig;
+    }
+}
+export const config = loadConfig();

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { apiClient, setToken } from './client';
+export type { AccountsApi, CountriesApi, MarketApi, ServerApi, StatisticsApi, WarsApi, } from './api';
+export type { SdkClient } from './client';

package/dist/index.js

@@ -0,0 +1 @@
+export { apiClient, setToken } from './client';

package/{src/types/accounts.ts → dist/types/accounts.d.ts}

@@ -8,10 +8,9 @@ export type AccountData = {
     total_mined_gold: number;
     total_builder_progress: number;
     day_of_birth: number;
-  }
-
-  export type EquipmentItem = {
+};
+export type EquipmentItem = {
     id: number;
     equipment_id: number;
     is_equipped: boolean;
-  }
+};

package/dist/types/accounts.js

@@ -0,0 +1 @@
+export {};

package/{src/types/country.ts → dist/types/country.d.ts}

@@ -1,23 +1,20 @@
 export type Currency = {
     id: number;
     name: string;
-    symbol: string; 
-  }
-  
-  export type Nation = {
+    symbol: string;
+};
+export type Nation = {
     id: number;
     name: string;
     avatar: string;
     currency: Currency;
     is_availible: boolean;
-  }
-
-  export interface RegionBonus {
-    type: string; 
+};
+export interface RegionBonus {
+    type: string;
     value: number;
-  }
-  
-  export type RegionFactories = {
+}
+export type RegionFactories = {
     food: number;
     weapon: number;
     oil: number;
@@ -26,9 +23,8 @@ export type Currency = {
     aircraft: number;
     titanium: number;
     tickets: number;
-  }
-  
-  export type Region = {
+};
+export type Region = {
     id: number;
     name: string;
     type: number;
@@ -39,4 +35,4 @@ export type Currency = {
     pollution: number;
     factories: RegionFactories;
     bonus: RegionBonus[];
-  }
+};

package/dist/types/country.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './market';
+export * from './server';
+export * from './accounts';
+export * from './country';
+export * from './statistics';
+export * from './wars';

package/dist/types/index.js

@@ -0,0 +1,6 @@
+export * from './market';
+export * from './server';
+export * from './accounts';
+export * from './country';
+export * from './statistics';
+export * from './wars';

package/dist/types/market.d.ts

@@ -0,0 +1,52 @@
+export interface ApiResponse<T> {
+    code: number;
+    description: string;
+    data: T;
+}
+export interface MarketCoinOffer {
+    amount: number;
+    rate: number;
+    owner: {
+        id: number;
+        type: string;
+    };
+}
+export interface MarketItemOffer {
+    amount: number;
+    rate: number;
+    owner: {
+        id: number;
+        type: string;
+    };
+}
+export interface MarketJobOffer {
+    value: number;
+    amount: number;
+    economic_skill: number;
+    currency_id: number;
+    business_id: number;
+}
+export interface MarketAuction {
+    id: number;
+    item: {
+        id: number;
+        type: string;
+    };
+    owner: {
+        id: number;
+        type: string;
+    };
+    initial_bid: number;
+    created_at: string;
+    end_at: string;
+    status: number;
+}
+export interface MarketAuctionBid {
+    id: number;
+    bid: number;
+    created_at: string;
+    owner: {
+        id: number;
+        type: string;
+    };
+}

package/dist/types/market.js

@@ -0,0 +1 @@
+export {};