@facturino/node 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Facturino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# Facturino Node.js SDK
+
+[![npm](https://img.shields.io/npm/v/@facturino/node)](https://www.npmjs.com/package/@facturino/node)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Official Node.js / TypeScript client for the [Facturino API](https://facturino.com/docs/api). Requires Node 18+.
+
+## Installation
+
+```bash
+npm install @facturino/node
+```
+
+## Usage
+
+```typescript
+import Facturino from '@facturino/node'
+
+const facturino = new Facturino('fac_test_xxx')
+
+const invoice = await facturino.invoices.create({
+  customerId: 'cus_xxx',
+  buyer: {
+    companyName: 'Acme SAS',
+    siret: '55208131766522',
+    address: { line1: '10 rue de la Paix', postalCode: '75002', city: 'Paris', country: 'FR' },
+  },
+  lines: [{
+    description: 'Consulting',
+    quantity: '1',      // decimal string
+    unit: 'flat_rate',
+    unitPrice: 10000,   // 100.00 EUR (centimes)
+    vatRate: 2000,      // 20.00% (centièmes de pourcent)
+    vatCode: 'S',
+  }],
+  dates: { issued: '2026-07-01', due: '2026-07-31' },
+  payment: { terms: 'Paiement à 30 jours', termsDays: 30, method: 'transfer', latePaymentRate: '10.00', collectionFee: '40.00' },
+})
+
+const finalized = await facturino.invoices.finalize(invoice.id)
+
+// One-shot: pass `autoFinalize: true` (and optionally
+// `autoSend: { email: true, pa: true }`) to `invoices.create(...)` to
+// finalize — and deliver by email and/or to the PA — in a single call.
+```
+
+## Configuration
+
+```typescript
+const facturino = new Facturino('fac_test_xxx', {
+  maxRetries: 3,      // retries on 429/5xx
+  timeout: 30000,     // ms
+  apiVersion: '2026-03-01',
+})
+```
+
+## Amounts
+
+Monetary values are integers in **centimes** (10000 = 100.00 EUR).
+VAT rates are integers in **centipercent** (2000 = 20.00%).
+
+## Pagination
+
+```typescript
+// Auto-paginate
+for await (const inv of facturino.invoices.list({ limit: 25 })) {
+  console.log(inv.id)
+}
+
+// Single page
+const page = await facturino.invoices.list({ status: 'draft' })
+```
+
+## Resources
+
+```typescript
+// Invoices
+facturino.invoices.create(params)
+facturino.invoices.get('inv_xxx')
+facturino.invoices.get('inv_xxx', { expand: ['customer', 'credit_notes'] })
+facturino.invoices.update('inv_xxx', params)
+facturino.invoices.del('inv_xxx')
+facturino.invoices.finalize('inv_xxx')
+facturino.invoices.send('inv_xxx')
+facturino.invoices.getPdf('inv_xxx')
+facturino.invoices.getFacturx('inv_xxx')
+facturino.invoices.getXml('inv_xxx', 'cii')
+facturino.invoices.list({ convertedFrom: 'quo_xxx' })  // invoices issued from a quote
+
+// Payments (sub-resource)
+facturino.invoices.payments.create('inv_xxx', { amount: 10000, method: 'transfer', paidAt: '...' })
+facturino.invoices.payments.list('inv_xxx')
+facturino.invoices.payments.cancel('inv_xxx', 'pay_xxx')
+
+// Customers
+facturino.customers.create(params)
+facturino.customers.lookup({ siret: '73282932000074' })
+// contacts[].role: 'billing' | 'technical' | 'main' (billing receives invoices)
+
+// Products
+facturino.products.list({ q: 'consult', category: 'services', active: true })
+
+// Quotes
+facturino.quotes.create(params)
+facturino.quotes.send('quo_xxx')
+facturino.quotes.accept('quo_xxx')
+facturino.quotes.convert('quo_xxx')  // -> draft invoice
+facturino.quotes.clone('quo_xxx')    // -> duplicated draft quote
+
+// Credit Notes
+facturino.creditNotes.create(params)
+facturino.creditNotes.finalize('crn_xxx')
+
+// Recurring Invoices
+facturino.recurringInvoices.create(params)
+facturino.recurringInvoices.pause('rec_xxx')
+facturino.recurringInvoices.resume('rec_xxx')
+
+// E-Reporting
+facturino.ereporting.createDeclaration(params)
+facturino.ereporting.submitDeclaration('erp_xxx')
+
+// Exports
+facturino.exports.generateFec({ period_start: '2026-01-01', period_end: '2026-12-31' })
+
+// Jobs
+facturino.jobs.poll('job_xxx')  // wait for async completion
+
+// Sandbox (test mode only)
+facturino.sandbox.resetData()
+facturino.sandbox.simulateStatus('inv_xxx', { status: 'approved' })
+
+// Reference & health (public, no auth)
+facturino.reference.listLegalForms({ search: 'SAS' })
+facturino.reference.listPaProviders()  // supported Plateformes Agréées (BYOPA)
+facturino.health.check()
+
+// Also: companies, events, webhookEndpoints, products
+```
+
+> **Public token endpoints** — the recipient-facing portals (`/pay/:token`,
+> `/portal/:token`, `/quote-portal/:token`) are intentionally not exposed by the
+> SDK: they are opened by the end recipient through a hosted page, not called
+> with an API key.
+
+## Webhooks
+
+```typescript
+app.post('/webhooks', express.raw({ type: 'application/json' }), (req, res) => {
+  try {
+    const event = facturino.webhooks.constructEvent(
+      req.body,
+      req.headers['facturino-signature'] as string,
+      'whsec_xxx',
+    )
+    console.log(event.type, event.data.id)
+    res.json({ received: true })
+  } catch (err) {
+    res.status(400).send('Invalid signature')
+  }
+})
+```
+
+## Idempotency
+
+```typescript
+await facturino.invoices.create(params, { idempotencyKey: 'unique-id' })
+```
+
+## Errors
+
+```typescript
+import { ApiError, RateLimitError, NotFoundError } from '@facturino/node'
+
+try {
+  await facturino.invoices.get('inv_xxx')
+} catch (err) {
+  if (err instanceof NotFoundError) { /* 404 */ }
+  if (err instanceof RateLimitError) { console.log(err.retryAfter) }
+  if (err instanceof ApiError) { console.log(err.code, err.requestId) }
+}
+```
+
+## TypeScript
+
+All types are exported:
+
+```typescript
+import type { Invoice, Customer, WebhookEvent } from '@facturino/node'
+```
+
+## Development
+
+```bash
+git clone https://github.com/facturino/facturino-node.git
+cd facturino-node
+npm install
+npm test
+npm run build
+```
+
+## License
+
+MIT

package/dist/cjs/client.d.ts

@@ -0,0 +1,24 @@
+import type { FacturinoConfig, RequestOptions } from './types.js';
+/** HTTP client with retries, exponential backoff, and structured errors. */
+export declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly maxRetries;
+    private readonly timeout;
+    private readonly apiVersion;
+    constructor(apiKey: string, config?: FacturinoConfig);
+    request<T>(method: string, path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body: unknown): Promise<T>;
+    del<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Map an HTTP status + error body to the most specific {@link ApiError}
+     * subclass. Both the status and the `error.type` from the body are used:
+     * the status decides the primary class (401 → Authentication, 429 →
+     * RateLimit…) but for 4xx codes that share a status — notably 422 vs
+     * 400 — we look at `body.error.type` to discriminate further.
+     */
+    private buildError;
+    private getRetryDelay;
+}

package/dist/cjs/client.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const errors_js_1 = require("./errors.js");
+const DEFAULT_BASE_URL = 'https://facturino.com/api';
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_API_VERSION = '2026-03-01';
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503]);
+const INITIAL_RETRY_DELAY_MS = 500;
+const MAX_RETRY_DELAY_MS = 30000;
+const VERSION = '1.0.0';
+/** HTTP client with retries, exponential backoff, and structured errors. */
+class HttpClient {
+    constructor(apiKey, config = {}) {
+        if (!apiKey) {
+            throw new Error('No API key provided. Pass your key as the first argument: new Facturino("fac_test_...")');
+        }
+        if (!apiKey.startsWith('fac_test_') && !apiKey.startsWith('fac_live_')) {
+            throw new Error('Invalid API key format. Keys must start with "fac_test_" or "fac_live_".');
+        }
+        this.apiKey = apiKey;
+        this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        this.apiVersion = config.apiVersion ?? DEFAULT_API_VERSION;
+    }
+    async request(method, path, body, options) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'Facturino-Version': this.apiVersion,
+            'User-Agent': `facturino-node/${VERSION}`,
+        };
+        if (options?.idempotencyKey) {
+            headers['Idempotency-Key'] = options.idempotencyKey;
+        }
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            if (attempt > 0) {
+                const delay = this.getRetryDelay(attempt, lastError);
+                await sleep(delay);
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+            try {
+                const fetchOptions = {
+                    method,
+                    headers,
+                    signal: controller.signal,
+                };
+                if (body !== undefined && method !== 'GET') {
+                    fetchOptions.body = JSON.stringify(body);
+                }
+                const response = await fetch(url, fetchOptions);
+                clearTimeout(timeoutId);
+                if (response.status === 204) {
+                    return undefined;
+                }
+                let responseBody;
+                const contentType = response.headers.get('content-type') ?? '';
+                if (contentType.includes('application/json')) {
+                    responseBody = await response.json();
+                }
+                else {
+                    const text = await response.text();
+                    responseBody = text;
+                }
+                if (response.ok) {
+                    return responseBody;
+                }
+                const errorBody = responseBody;
+                const hasStructuredError = errorBody &&
+                    typeof errorBody === 'object' &&
+                    'error' in errorBody &&
+                    typeof errorBody.error === 'object';
+                if (!hasStructuredError) {
+                    const syntheticError = {
+                        error: {
+                            type: 'api_error',
+                            code: 'unknown',
+                            message: typeof responseBody === 'string' ? responseBody : `HTTP ${response.status}`,
+                            request_id: response.headers.get('x-request-id') ?? 'req_unknown',
+                        },
+                    };
+                    lastError = this.buildError(response.status, syntheticError, response.headers);
+                }
+                else {
+                    lastError = this.buildError(response.status, errorBody, response.headers);
+                }
+                if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+                    continue;
+                }
+                throw lastError;
+            }
+            catch (err) {
+                clearTimeout(timeoutId);
+                if (err instanceof errors_js_1.ApiError) {
+                    throw err;
+                }
+                if (err instanceof Error && err.name === 'AbortError') {
+                    lastError = new errors_js_1.ConnectionError(`Request to ${method} ${path} timed out after ${this.timeout}ms`);
+                    if (attempt < this.maxRetries) {
+                        continue;
+                    }
+                    throw lastError;
+                }
+                if (err instanceof TypeError && (err.message.includes('fetch') || err.message.includes('network'))) {
+                    lastError = new errors_js_1.ConnectionError(`Network error on ${method} ${path}: ${err.message}`);
+                    if (attempt < this.maxRetries) {
+                        continue;
+                    }
+                    throw lastError;
+                }
+                throw err;
+            }
+        }
+        throw lastError ?? new errors_js_1.ConnectionError('Request failed after all retries');
+    }
+    async get(path) {
+        return this.request('GET', path);
+    }
+    async post(path, body, options) {
+        return this.request('POST', path, body, options);
+    }
+    async patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    async del(path, body) {
+        return this.request('DELETE', path, body);
+    }
+    /**
+     * Map an HTTP status + error body to the most specific {@link ApiError}
+     * subclass. Both the status and the `error.type` from the body are used:
+     * the status decides the primary class (401 → Authentication, 429 →
+     * RateLimit…) but for 4xx codes that share a status — notably 422 vs
+     * 400 — we look at `body.error.type` to discriminate further.
+     */
+    buildError(status, body, headers) {
+        const type = body?.error?.type;
+        switch (status) {
+            case 400:
+                return new errors_js_1.InvalidRequestError(status, body);
+            case 401:
+                return new errors_js_1.AuthenticationError(status, body);
+            case 402:
+                return new errors_js_1.PlanLimitError(status, body);
+            case 403:
+                return new errors_js_1.PermissionError(status, body);
+            case 404:
+                return new errors_js_1.NotFoundError(status, body);
+            case 409:
+                return new errors_js_1.ConflictError(status, body);
+            case 422:
+                return new errors_js_1.ValidationError(status, body);
+            case 429: {
+                const retryAfterHeader = headers.get('retry-after');
+                const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : null;
+                return new errors_js_1.RateLimitError(status, body, Number.isNaN(retryAfter) ? null : retryAfter);
+            }
+            case 500:
+            case 502:
+            case 503:
+            case 504:
+                return new errors_js_1.ApiInternalError(status, body);
+            default:
+                // Use the body `type` as a fallback for non-standard status codes so
+                // a 418 with `type: 'rate_limit_error'` still maps to the right
+                // class instead of falling through to the generic `ApiError`.
+                if (type === 'validation_error')
+                    return new errors_js_1.ValidationError(status, body);
+                if (type === 'authentication_error')
+                    return new errors_js_1.AuthenticationError(status, body);
+                if (type === 'permission_error')
+                    return new errors_js_1.PermissionError(status, body);
+                if (type === 'conflict_error')
+                    return new errors_js_1.ConflictError(status, body);
+                if (type === 'plan_limit_error')
+                    return new errors_js_1.PlanLimitError(status, body);
+                if (type === 'rate_limit_error')
+                    return new errors_js_1.RateLimitError(status, body, null);
+                if (type === 'not_found_error')
+                    return new errors_js_1.NotFoundError(status, body);
+                if (type === 'api_error')
+                    return new errors_js_1.ApiInternalError(status, body);
+                return new errors_js_1.ApiError(status, body);
+        }
+    }
+    getRetryDelay(attempt, lastError) {
+        if (lastError instanceof errors_js_1.RateLimitError && lastError.retryAfter !== null) {
+            return Math.min(lastError.retryAfter * 1000, MAX_RETRY_DELAY_MS);
+        }
+        const baseDelay = INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+        const jitter = baseDelay * 0.2 * Math.random();
+        return Math.min(baseDelay + jitter, MAX_RETRY_DELAY_MS);
+    }
+}
+exports.HttpClient = HttpClient;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/cjs/errors.d.ts

@@ -0,0 +1,76 @@
+import type { ApiErrorBody } from './types.js';
+/** Base SDK error. */
+export declare class FacturinoError extends Error {
+    constructor(message: string);
+}
+/** Structured API error response. */
+export declare class ApiError extends FacturinoError {
+    readonly status: number;
+    readonly type: string;
+    readonly code: string;
+    readonly param?: string;
+    readonly docUrl?: string;
+    readonly requestId: string;
+    readonly hint?: string;
+    constructor(status: number, body: ApiErrorBody);
+}
+/**
+ * 400 — request payload is malformed, a field is missing or invalid.
+ * Inspect `error.param` to identify the offending field.
+ */
+export declare class InvalidRequestError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/**
+ * 422 — Zod schema validation rejected the payload. The offending field is
+ * surfaced in `error.param`. Distinct from {@link InvalidRequestError} so
+ * callers can differentiate "shape malformed" (400) from "value out of
+ * range / wrong type" (422) when re-displaying validation feedback.
+ */
+export declare class ValidationError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/** 401 — invalid, revoked, or missing API key. */
+export declare class AuthenticationError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/**
+ * 403 — the API key authenticated successfully but lacks the scope required
+ * for the requested operation. The required scope is exposed in
+ * `error.param`.
+ */
+export declare class PermissionError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/** 404 — resource not found, or not visible with this key's livemode. */
+export declare class NotFoundError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/**
+ * 409 — the request conflicts with the current state of the resource
+ * (state-machine transition refused, finalized invoice cannot be edited,
+ * idempotency key reused with a different payload).
+ */
+export declare class ConflictError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/** 429 — rate limit exceeded. `retryAfter` is the recommended back-off in seconds. */
+export declare class RateLimitError extends ApiError {
+    readonly retryAfter: number | null;
+    constructor(status: number, body: ApiErrorBody, retryAfter: number | null);
+}
+/** 402 — quota or plan limit exceeded. Upgrade or revoke resources to recover. */
+export declare class PlanLimitError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/**
+ * 500/503 — Facturino is experiencing an internal error. The API is monitored
+ * automatically; safe to retry with exponential back-off.
+ */
+export declare class ApiInternalError extends ApiError {
+    constructor(status: number, body: ApiErrorBody);
+}
+/** Network or timeout error. Not surfaced by the API itself. */
+export declare class ConnectionError extends FacturinoError {
+    constructor(message: string);
+}

package/dist/cjs/errors.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionError = exports.ApiInternalError = exports.PlanLimitError = exports.RateLimitError = exports.ConflictError = exports.NotFoundError = exports.PermissionError = exports.AuthenticationError = exports.ValidationError = exports.InvalidRequestError = exports.ApiError = exports.FacturinoError = void 0;
+/** Base SDK error. */
+class FacturinoError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FacturinoError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.FacturinoError = FacturinoError;
+/** Structured API error response. */
+class ApiError extends FacturinoError {
+    constructor(status, body) {
+        const err = body.error;
+        super(err.message);
+        this.name = 'ApiError';
+        this.status = status;
+        this.type = err.type;
+        this.code = err.code;
+        this.param = err.param;
+        this.docUrl = err.doc_url;
+        this.requestId = err.request_id;
+        this.hint = err.hint;
+    }
+}
+exports.ApiError = ApiError;
+/**
+ * 400 — request payload is malformed, a field is missing or invalid.
+ * Inspect `error.param` to identify the offending field.
+ */
+class InvalidRequestError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'InvalidRequestError';
+    }
+}
+exports.InvalidRequestError = InvalidRequestError;
+/**
+ * 422 — Zod schema validation rejected the payload. The offending field is
+ * surfaced in `error.param`. Distinct from {@link InvalidRequestError} so
+ * callers can differentiate "shape malformed" (400) from "value out of
+ * range / wrong type" (422) when re-displaying validation feedback.
+ */
+class ValidationError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+/** 401 — invalid, revoked, or missing API key. */
+class AuthenticationError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/**
+ * 403 — the API key authenticated successfully but lacks the scope required
+ * for the requested operation. The required scope is exposed in
+ * `error.param`.
+ */
+class PermissionError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'PermissionError';
+    }
+}
+exports.PermissionError = PermissionError;
+/** 404 — resource not found, or not visible with this key's livemode. */
+class NotFoundError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * 409 — the request conflicts with the current state of the resource
+ * (state-machine transition refused, finalized invoice cannot be edited,
+ * idempotency key reused with a different payload).
+ */
+class ConflictError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'ConflictError';
+    }
+}
+exports.ConflictError = ConflictError;
+/** 429 — rate limit exceeded. `retryAfter` is the recommended back-off in seconds. */
+class RateLimitError extends ApiError {
+    constructor(status, body, retryAfter) {
+        super(status, body);
+        this.name = 'RateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+exports.RateLimitError = RateLimitError;
+/** 402 — quota or plan limit exceeded. Upgrade or revoke resources to recover. */
+class PlanLimitError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'PlanLimitError';
+    }
+}
+exports.PlanLimitError = PlanLimitError;
+/**
+ * 500/503 — Facturino is experiencing an internal error. The API is monitored
+ * automatically; safe to retry with exponential back-off.
+ */
+class ApiInternalError extends ApiError {
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'ApiInternalError';
+    }
+}
+exports.ApiInternalError = ApiInternalError;
+/** Network or timeout error. Not surfaced by the API itself. */
+class ConnectionError extends FacturinoError {
+    constructor(message) {
+        super(message);
+        this.name = 'ConnectionError';
+    }
+}
+exports.ConnectionError = ConnectionError;