@hasna/connectors 1.3.42 → 1.3.43

package/connectors/smile-io/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@hasna/connect-smile-io",
+  "version": "0.1.0",
+  "description": "Smile.io connector CLI - loyalty, points, rewards, and referrals with multi-profile support",
+  "type": "module",
+  "bin": {
+    "connect-smile-io": "./bin/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
+    "dev": "bun run ./src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "smile-io",
+    "loyalty",
+    "rewards",
+    "points",
+    "referrals",
+    "api",
+    "connector",
+    "cli",
+    "typescript",
+    "bun",
+    "hasna"
+  ],
+  "author": "Hasna",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/connectors.git"
+  }
+}

package/connectors/smile-io/src/api/activities.ts

@@ -0,0 +1,22 @@
+import type { SmileClient } from './client';
+import type { Activity, ActivityResponse, CreateActivityInput } from '../types';
+
+/**
+ * Activities API — record a customer action for reward evaluation.
+ * Endpoint: POST /activities
+ */
+export class ActivitiesApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /**
+   * Record an activity. Provide either `customer_id` or `customer_email`.
+   * Smile evaluates the activity against the program's earning rules.
+   */
+  async create(input: CreateActivityInput): Promise<Activity> {
+    const response = await this.client.request<ActivityResponse>('/activities', {
+      method: 'POST',
+      body: { activity: input },
+    });
+    return response.activity;
+  }
+}

package/connectors/smile-io/src/api/client.test.ts

@@ -0,0 +1,153 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { Smile, SmileClient } from './index';
+import { SmileApiError } from '../types';
+
+const realFetch = globalThis.fetch;
+
+interface Recorded {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body?: unknown;
+}
+
+interface MockResult {
+  status?: number;
+  json?: unknown;
+}
+
+function installFetch(handler: (url: string, init: RequestInit | undefined) => MockResult) {
+  const recorded: Recorded[] = [];
+  globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+    const url = typeof input === 'string' ? input : input.toString();
+    const headers = (init?.headers as Record<string, string>) ?? {};
+    recorded.push({ url, method: init?.method ?? 'GET', headers, body: init?.body });
+    const { status = 200, json = {} } = handler(url, init);
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      statusText: status === 200 ? 'OK' : 'Error',
+      async text() {
+        return JSON.stringify(json ?? {});
+      },
+    } as Response;
+  }) as typeof fetch;
+  return recorded;
+}
+
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+describe('SmileClient transport', () => {
+  test('requires an API key', () => {
+    expect(() => new SmileClient({ apiKey: '' })).toThrow();
+  });
+
+  test('fromEnv requires SMILEIO_API_KEY', () => {
+    const prev = process.env.SMILEIO_API_KEY;
+    delete process.env.SMILEIO_API_KEY;
+    expect(() => Smile.fromEnv()).toThrow(/SMILEIO_API_KEY/);
+    if (prev !== undefined) process.env.SMILEIO_API_KEY = prev;
+  });
+
+  test('uses the v1 base URL and Bearer authorization header', async () => {
+    const recorded = installFetch(() => ({ json: { customers: [], metadata: {} } }));
+    const smile = new Smile({ apiKey: 'api_secret_key' });
+    await smile.customers.list();
+
+    expect(recorded[0].url).toContain('https://api.smile.io/v1/customers');
+    expect(recorded[0].method).toBe('GET');
+    expect(recorded[0].headers.Authorization).toBe('Bearer api_secret_key');
+  });
+
+  test('honors a custom base URL and trims a trailing slash', async () => {
+    const recorded = installFetch(() => ({ json: { points_settings: { points_label: { one: 'Point', other: 'Points' } } } }));
+    const smile = new Smile({ apiKey: 'k', baseUrl: 'https://proxy.example.com/v1/' });
+    await smile.pointsSettings.get();
+
+    expect(recorded[0].url).toBe('https://proxy.example.com/v1/points_settings');
+  });
+
+  test('serializes query parameters and omits undefined values', async () => {
+    const recorded = installFetch(() => ({ json: { customers: [], metadata: {} } }));
+    const smile = new Smile({ apiKey: 'k' });
+    await smile.customers.list({ email: 'jane@doe.com', state: 'member', limit: 25, cursor: undefined });
+
+    const url = new URL(recorded[0].url);
+    expect(url.searchParams.get('email')).toBe('jane@doe.com');
+    expect(url.searchParams.get('state')).toBe('member');
+    expect(url.searchParams.get('limit')).toBe('25');
+    expect(url.searchParams.has('cursor')).toBe(false);
+  });
+
+  test('sends JSON body for POST and returns the unwrapped resource', async () => {
+    const recorded = installFetch(() => ({
+      status: 201,
+      json: {
+        points_transaction: {
+          id: 1,
+          customer_id: 42,
+          points_change: 100,
+          description: 'Bonus',
+          internal_note: null,
+          created_at: 't',
+          updated_at: 't',
+        },
+      },
+    }));
+    const smile = new Smile({ apiKey: 'k' });
+    const tx = await smile.pointsTransactions.create({ customer_id: 42, points_change: 100, description: 'Bonus' });
+
+    const call = recorded[0];
+    expect(call.method).toBe('POST');
+    expect(call.headers['Content-Type']).toBe('application/json');
+    expect(JSON.parse(call.body as string)).toEqual({ customer_id: 42, points_change: 100, description: 'Bonus' });
+    expect(tx.id).toBe(1);
+    expect(tx.points_change).toBe(100);
+  });
+
+  test('wraps activity payloads in an activity object', async () => {
+    const recorded = installFetch(() => ({
+      status: 201,
+      json: { activity: { id: 5, customer_id: 42, token: 'activity_x', distinct_id: null, created_on_origin_at: null, created_at: 't', updated_at: 't' } },
+    }));
+    const smile = new Smile({ apiKey: 'k' });
+    await smile.activities.create({ token: 'activity_x', customer_id: 42 });
+
+    expect(JSON.parse(recorded[0].body as string)).toEqual({ activity: { token: 'activity_x', customer_id: 42 } });
+  });
+
+  test('purchase targets the nested points_products/{id}/purchase path', async () => {
+    const recorded = installFetch(() => ({
+      status: 201,
+      json: { points_purchase: { id: 9, customer_id: 42, points_product_id: 7, points_spent: 500, reward_fulfillment: {}, created_at: 't', updated_at: 't' } },
+    }));
+    const smile = new Smile({ apiKey: 'k' });
+    await smile.pointsProducts.purchase(7, { customer_id: 42, points_to_spend: 500 });
+
+    expect(recorded[0].url).toContain('/points_products/7/purchase');
+    expect(JSON.parse(recorded[0].body as string)).toEqual({ customer_id: 42, points_to_spend: 500 });
+  });
+
+  test('raises SmileApiError with status and parsed message on non-2xx', async () => {
+    installFetch(() => ({ status: 422, json: { errors: { points_change: ['would result in a negative balance'] } } }));
+    const smile = new Smile({ apiKey: 'k' });
+
+    let caught: unknown;
+    try {
+      await smile.pointsTransactions.create({ customer_id: 1, points_change: -5 });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(SmileApiError);
+    expect((caught as SmileApiError).statusCode).toBe(422);
+    expect((caught as SmileApiError).message).toContain('points_change');
+  });
+
+  test('parses a string error field', async () => {
+    installFetch(() => ({ status: 404, json: { error: 'Not found' } }));
+    const smile = new Smile({ apiKey: 'k' });
+    await expect(smile.customers.get(999)).rejects.toThrow('Not found');
+  });
+});

package/connectors/smile-io/src/api/client.ts

@@ -0,0 +1,120 @@
+import type { SmileConfig } from '../types';
+import { SmileApiError } from '../types';
+
+const DEFAULT_BASE_URL = 'https://api.smile.io/v1';
+
+export type QueryValue = string | number | boolean | undefined | null;
+
+export interface SmileRequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+  params?: Record<string, QueryValue>;
+  body?: Record<string, unknown>;
+  headers?: Record<string, string>;
+}
+
+/**
+ * Low-level HTTP client for the Smile.io REST API.
+ *
+ * Authentication is a private API key sent as a Bearer token:
+ *   Authorization: Bearer <apiKey>
+ */
+export class SmileClient {
+  private readonly apiKey: string;
+  private readonly baseUrl: string;
+
+  constructor(config: SmileConfig) {
+    if (!config.apiKey) {
+      throw new Error('Smile.io API key is required');
+    }
+    this.apiKey = config.apiKey;
+    // Trim a trailing slash so `${baseUrl}${path}` stays well-formed.
+    this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, '');
+  }
+
+  /**
+   * Perform an authenticated request against the Smile.io API.
+   * `endpoint` is a path relative to the base URL (e.g. `/customers`).
+   */
+  async request<T>(endpoint: string, options: SmileRequestOptions = {}): Promise<T> {
+    const { method = 'GET', params, body, headers = {} } = options;
+
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+
+    const requestHeaders: Record<string, string> = {
+      Authorization: `Bearer ${this.apiKey}`,
+      Accept: 'application/json',
+      ...headers,
+    };
+
+    const init: RequestInit = { method, headers: requestHeaders };
+    if (body !== undefined && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) {
+      requestHeaders['Content-Type'] = 'application/json';
+      init.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url.toString(), init);
+
+    // 204 No Content and empty bodies have nothing to parse.
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    const text = await response.text();
+    let data: unknown = {};
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = { message: text };
+      }
+    }
+
+    if (!response.ok) {
+      throw new SmileApiError(
+        extractErrorMessage(data, response),
+        response.status,
+        (data as { errors?: unknown })?.errors,
+      );
+    }
+
+    return data as T;
+  }
+}
+
+/**
+ * Smile.io error payloads vary in shape. Common forms:
+ *   { "error": "Not found" }
+ *   { "message": "..." }
+ *   { "errors": { "field": ["is invalid"] } }
+ *   { "errors": ["something went wrong"] }
+ */
+function extractErrorMessage(data: unknown, response: Response): string {
+  const fallback = `Smile.io API error: ${response.status} ${response.statusText}`;
+  if (typeof data !== 'object' || data === null) {
+    return fallback;
+  }
+
+  const record = data as Record<string, unknown>;
+  if (typeof record.error === 'string') return record.error;
+  if (typeof record.message === 'string') return record.message;
+
+  const { errors } = record;
+  if (typeof errors === 'string') return errors;
+  if (Array.isArray(errors)) return errors.map(String).join('; ');
+  if (errors && typeof errors === 'object') {
+    const parts = Object.entries(errors as Record<string, unknown>).map(([field, value]) => {
+      const detail = Array.isArray(value) ? value.map(String).join(', ') : String(value);
+      return `${field}: ${detail}`;
+    });
+    if (parts.length > 0) return parts.join('; ');
+  }
+
+  return fallback;
+}

package/connectors/smile-io/src/api/customerIdentities.ts

@@ -0,0 +1,26 @@
+import type { SmileClient } from './client';
+import type {
+  CreateCustomerIdentityInput,
+  CustomerIdentity,
+  CustomerIdentityResponse,
+} from '../types';
+
+/**
+ * Customer Identities API — links external users to Smile customers.
+ * Endpoint: POST /customer_identities/create_or_update
+ */
+export class CustomerIdentitiesApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /**
+   * Create or update a customer identity. Matches on `distinct_id`:
+   * a new identity (and customer) is created when none exists.
+   */
+  async createOrUpdate(input: CreateCustomerIdentityInput): Promise<CustomerIdentity> {
+    const response = await this.client.request<CustomerIdentityResponse>(
+      '/customer_identities/create_or_update',
+      { method: 'POST', body: { customer_identity: input } },
+    );
+    return response.customer_identity;
+  }
+}

package/connectors/smile-io/src/api/customers.ts

@@ -0,0 +1,37 @@
+import type { SmileClient } from './client';
+import type {
+  Customer,
+  CustomerResponse,
+  ListCustomersOptions,
+  ListCustomersResponse,
+} from '../types';
+
+/**
+ * Customers API — the loyalty program members.
+ * Endpoints: GET /customers, GET /customers/{id}
+ */
+export class CustomersApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /** List customers with optional filters and cursor pagination. */
+  async list(options: ListCustomersOptions = {}): Promise<ListCustomersResponse> {
+    return this.client.request<ListCustomersResponse>('/customers', {
+      params: {
+        email: options.email,
+        state: options.state,
+        updated_at_min: options.updated_at_min,
+        limit: options.limit,
+        cursor: options.cursor,
+        include: options.include,
+      },
+    });
+  }
+
+  /** Retrieve a single customer by Smile customer ID. */
+  async get(id: number, include?: string): Promise<Customer> {
+    const response = await this.client.request<CustomerResponse>(`/customers/${id}`, {
+      params: { include },
+    });
+    return response.customer;
+  }
+}

package/connectors/smile-io/src/api/earningRules.ts

@@ -0,0 +1,17 @@
+import type { SmileClient } from './client';
+import type { ListEarningRulesOptions, ListEarningRulesResponse } from '../types';
+
+/**
+ * Earning Rules API — the ways customers earn points.
+ * Endpoint: GET /earning_rules
+ */
+export class EarningRulesApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /** List earning rules with cursor pagination. */
+  async list(options: ListEarningRulesOptions = {}): Promise<ListEarningRulesResponse> {
+    return this.client.request<ListEarningRulesResponse>('/earning_rules', {
+      params: { limit: options.limit, cursor: options.cursor },
+    });
+  }
+}

package/connectors/smile-io/src/api/index.ts

@@ -0,0 +1,70 @@
+import type { SmileConfig } from '../types';
+import { SmileClient } from './client';
+import { CustomersApi } from './customers';
+import { CustomerIdentitiesApi } from './customerIdentities';
+import { PointsTransactionsApi } from './pointsTransactions';
+import { PointsProductsApi } from './pointsProducts';
+import { ActivitiesApi } from './activities';
+import { EarningRulesApi } from './earningRules';
+import { VipTiersApi } from './vipTiers';
+import { PointsSettingsApi } from './pointsSettings';
+import { RewardFulfillmentsApi } from './rewardFulfillments';
+
+/**
+ * Main Smile.io connector.
+ * Wraps the REST API resource groups behind a single authenticated client.
+ */
+export class Smile {
+  private readonly client: SmileClient;
+
+  public readonly customers: CustomersApi;
+  public readonly customerIdentities: CustomerIdentitiesApi;
+  public readonly pointsTransactions: PointsTransactionsApi;
+  public readonly pointsProducts: PointsProductsApi;
+  public readonly activities: ActivitiesApi;
+  public readonly earningRules: EarningRulesApi;
+  public readonly vipTiers: VipTiersApi;
+  public readonly pointsSettings: PointsSettingsApi;
+  public readonly rewardFulfillments: RewardFulfillmentsApi;
+
+  constructor(config: SmileConfig) {
+    this.client = new SmileClient(config);
+    this.customers = new CustomersApi(this.client);
+    this.customerIdentities = new CustomerIdentitiesApi(this.client);
+    this.pointsTransactions = new PointsTransactionsApi(this.client);
+    this.pointsProducts = new PointsProductsApi(this.client);
+    this.activities = new ActivitiesApi(this.client);
+    this.earningRules = new EarningRulesApi(this.client);
+    this.vipTiers = new VipTiersApi(this.client);
+    this.pointsSettings = new PointsSettingsApi(this.client);
+    this.rewardFulfillments = new RewardFulfillmentsApi(this.client);
+  }
+
+  /**
+   * Build a Smile client from environment variables.
+   * Reads SMILEIO_API_KEY (required) and SMILEIO_BASE_URL (optional).
+   */
+  static fromEnv(): Smile {
+    const apiKey = process.env.SMILEIO_API_KEY;
+    if (!apiKey) {
+      throw new Error('SMILEIO_API_KEY environment variable is required');
+    }
+    return new Smile({ apiKey, baseUrl: process.env.SMILEIO_BASE_URL });
+  }
+
+  /** Access the underlying HTTP client for advanced/raw requests. */
+  getClient(): SmileClient {
+    return this.client;
+  }
+}
+
+export { SmileClient } from './client';
+export { CustomersApi } from './customers';
+export { CustomerIdentitiesApi } from './customerIdentities';
+export { PointsTransactionsApi } from './pointsTransactions';
+export { PointsProductsApi } from './pointsProducts';
+export { ActivitiesApi } from './activities';
+export { EarningRulesApi } from './earningRules';
+export { VipTiersApi } from './vipTiers';
+export { PointsSettingsApi } from './pointsSettings';
+export { RewardFulfillmentsApi } from './rewardFulfillments';

package/connectors/smile-io/src/api/pointsProducts.ts

@@ -0,0 +1,48 @@
+import type { SmileClient } from './client';
+import type {
+  ListPointsProductsOptions,
+  ListPointsProductsResponse,
+  PointsProduct,
+  PointsProductResponse,
+  PointsPurchase,
+  PointsPurchaseResponse,
+  PurchasePointsProductInput,
+} from '../types';
+
+/**
+ * Points Products API — the reward options customers redeem points for.
+ * Endpoints: GET /points_products, GET /points_products/{id},
+ *            POST /points_products/{id}/purchase
+ */
+export class PointsProductsApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /** List points products (page-based pagination). */
+  async list(options: ListPointsProductsOptions = {}): Promise<ListPointsProductsResponse> {
+    return this.client.request<ListPointsProductsResponse>('/points_products', {
+      params: {
+        exchange_type: options.exchange_type,
+        page: options.page,
+        page_size: options.page_size,
+      },
+    });
+  }
+
+  /** Retrieve a single points product by ID. */
+  async get(id: number): Promise<PointsProduct> {
+    const response = await this.client.request<PointsProductResponse>(`/points_products/${id}`);
+    return response.points_product;
+  }
+
+  /**
+   * Redeem a points product on behalf of a customer.
+   * `points_to_spend` only applies to `variable` exchange-type products.
+   */
+  async purchase(id: number, input: PurchasePointsProductInput): Promise<PointsPurchase> {
+    const response = await this.client.request<PointsPurchaseResponse>(
+      `/points_products/${id}/purchase`,
+      { method: 'POST', body: { ...input } },
+    );
+    return response.points_purchase;
+  }
+}

package/connectors/smile-io/src/api/pointsSettings.ts

@@ -0,0 +1,16 @@
+import type { SmileClient } from './client';
+import type { PointsSettings, PointsSettingsResponse } from '../types';
+
+/**
+ * Points Settings API — the account's points currency branding.
+ * Endpoint: GET /points_settings
+ */
+export class PointsSettingsApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /** Get the account's points settings (points label singular/plural). */
+  async get(): Promise<PointsSettings> {
+    const response = await this.client.request<PointsSettingsResponse>('/points_settings');
+    return response.points_settings;
+  }
+}

package/connectors/smile-io/src/api/pointsTransactions.ts

@@ -0,0 +1,50 @@
+import type { SmileClient } from './client';
+import type {
+  CreatePointsTransactionInput,
+  ListPointsTransactionsOptions,
+  ListPointsTransactionsResponse,
+  PointsTransaction,
+  PointsTransactionResponse,
+} from '../types';
+
+/**
+ * Points Transactions API — award or deduct points.
+ * Endpoints: GET /points_transactions, GET /points_transactions/{id},
+ *            POST /points_transactions
+ */
+export class PointsTransactionsApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /** List points transactions, optionally filtered by customer. */
+  async list(options: ListPointsTransactionsOptions = {}): Promise<ListPointsTransactionsResponse> {
+    return this.client.request<ListPointsTransactionsResponse>('/points_transactions', {
+      params: {
+        customer_id: options.customer_id,
+        updated_at_min: options.updated_at_min,
+        limit: options.limit,
+        cursor: options.cursor,
+      },
+    });
+  }
+
+  /** Retrieve a single points transaction by ID. */
+  async get(id: number): Promise<PointsTransaction> {
+    const response = await this.client.request<PointsTransactionResponse>(
+      `/points_transactions/${id}`,
+    );
+    return response.points_transaction;
+  }
+
+  /**
+   * Create a points transaction. Use a positive `points_change` to add points
+   * and a negative value to subtract. Requests that would drive the balance
+   * negative are rejected by the API.
+   */
+  async create(input: CreatePointsTransactionInput): Promise<PointsTransaction> {
+    const response = await this.client.request<PointsTransactionResponse>('/points_transactions', {
+      method: 'POST',
+      body: { ...input },
+    });
+    return response.points_transaction;
+  }
+}

package/connectors/smile-io/src/api/rewardFulfillments.ts

@@ -0,0 +1,29 @@
+import type { SmileClient } from './client';
+import type {
+  ListRewardFulfillmentsOptions,
+  ListRewardFulfillmentsResponse,
+} from '../types';
+
+/**
+ * Reward Fulfillments API — rewards issued to customers.
+ * Endpoint: GET /reward_fulfillments
+ */
+export class RewardFulfillmentsApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /** List reward fulfillments with optional filters and cursor pagination. */
+  async list(
+    options: ListRewardFulfillmentsOptions = {},
+  ): Promise<ListRewardFulfillmentsResponse> {
+    return this.client.request<ListRewardFulfillmentsResponse>('/reward_fulfillments', {
+      params: {
+        customer_id: options.customer_id,
+        fulfillment_status: options.fulfillment_status,
+        usage_status: options.usage_status,
+        updated_at_min: options.updated_at_min,
+        limit: options.limit,
+        cursor: options.cursor,
+      },
+    });
+  }
+}

package/connectors/smile-io/src/api/vipTiers.ts

@@ -0,0 +1,21 @@
+import type { SmileClient } from './client';
+import type { ListVipTiersOptions, ListVipTiersResponse, VipTier } from '../types';
+
+/**
+ * VIP Tiers API — the program's VIP levels.
+ * Endpoint: GET /vip_tiers
+ */
+export class VipTiersApi {
+  constructor(private readonly client: SmileClient) {}
+
+  /**
+   * List VIP tiers (sorted ascending by milestone, no pagination).
+   * `include` accepts `perks` and/or `entry_rewards`.
+   */
+  async list(options: ListVipTiersOptions = {}): Promise<VipTier[]> {
+    const response = await this.client.request<ListVipTiersResponse>('/vip_tiers', {
+      params: { include: options.include },
+    });
+    return response.vip_tiers;
+  }
+}