@memberjunction/connector-everhour 0.2.0

package/dist/EverhourConnector.d.ts

@@ -0,0 +1,228 @@
+import { type UserInfo } from '@memberjunction/core';
+import type { MJCompanyIntegrationEntity, MJIntegrationObjectEntity, MJIntegrationObjectFieldEntity } from '@memberjunction/core-entities';
+import { BaseRESTIntegrationConnector, type RESTAuthContext, type RESTResponse, type PaginationState, type PaginationType, type ConnectionTestResult, type FetchContext, type FetchBatchResult } from '@memberjunction/integration-engine';
+/**
+ * Everhour time-tracking connector (REST API v1.2, read-only).
+ *
+ * ── Everhour ids carry a platform prefix, and that is the whole `as:` story ──
+ * An Everhour project id is literally `as:1234567890` (Asana-sourced), `jr:…` (Jira), `ev:…` (native),
+ * and so on — the prefix is part of the vendor's own identifier, documented in its Project schema, not
+ * an addressing convention a caller adds. The legacy AIDP driver looked like it was doing something
+ * exotic (`/projects/as:${externalId}/tasks`) only because it had *stripped* the prefix on the way in,
+ * with `id.slice(3)`, to make the remainder match an Asana gid — then had to put it back to make the
+ * next call. This connector keeps every id exactly as Everhour issued it, so the prefix never has to
+ * be reconstructed and the connector never has to know that some Everhour workspaces are backed by
+ * Asana. Nothing here is Asana-aware.
+ *
+ * ── Vendor units are preserved, not converted ──
+ * Everhour reports money in cents and durations in seconds. The legacy driver divided fees, rates and
+ * budgets by 100 on the way into AIDP's schema; that is a presentation choice belonging to whoever
+ * consumes the data, and doing it here would make the landed value disagree with what the API returned
+ * and with what Everhour's own UI reports. Every amount lands in the vendor's unit and every field
+ * description names that unit.
+ *
+ * ── Time records come from the team-wide door, not per project ──
+ * The legacy driver read time one project at a time (`/projects/{id}/time`), which is an N+1 over the
+ * project list and, at Everhour's ~20 requests / 10 seconds, the dominant cost of a run. Everhour also
+ * publishes `/team/time?from=&to=`, which returns the same records for the whole team in one paged
+ * stream. TimeRecords therefore has no parent door at all, and `from`/`to` gives the incremental
+ * filter directly.
+ *
+ * ── Tasks is a templated child door ──
+ * Everhour exposes no unfiltered team-wide task listing (`/tasks/search` requires a search term), so
+ * tasks are addressable only per project. Tasks declares `Configuration.parentObjectName: "Projects"`
+ * so the engine iterates the already-synced projects; without that declaration it would fetch zero
+ * rows and the run would still report success.
+ */
+export declare class EverhourConnector extends BaseRESTIntegrationConnector {
+    /** Verbatim three-way invariant name: ClassName / IntegrationName getter / MJ: Integrations.Name. */
+    get IntegrationName(): string;
+    /**
+     * The only incremental object is TimeRecords, watermarked on `date`, and the watermark only ever
+     * advances to the maximum date actually observed. Records are never re-dated backwards by Everhour
+     * — an edit changes `time`/`comment`, not which day the work happened — so the high-water mark is
+     * monotonic even though the records behind it are mutable. The lookback window below is what
+     * covers those mutations.
+     */
+    get MonotonicWatermark(): boolean;
+    /**
+     * Everhour's list endpoints document no ordering guarantee and offer no sort parameter, so there
+     * is no key a keyset resume could resume against. Paging is `page`/`limit`.
+     */
+    StableOrderingKey(_objectName: string): string | null;
+    /**
+     * The watermark for the object currently being fetched, stashed by FetchChanges so
+     * AppendDefaultQueryParams — which the base calls per page and which receives no context — can
+     * apply the `from`/`to` window. Cleared on the way out so a non-incremental object can never
+     * inherit the previous object's filter.
+     */
+    protected currentWatermark: string | null;
+    /**
+     * Resolves the API key. Everhour has no separate tenant identifier: the key *is* the team scope,
+     * which is why nothing here reads ExternalSystemID and why there is no workspace parameter on any
+     * request.
+     */
+    protected Authenticate(companyIntegration: MJCompanyIntegrationEntity, contextUser: UserInfo): Promise<EverhourAuthContext>;
+    protected BuildHeaders(auth: EverhourAuthContext): Record<string, string>;
+    protected GetBaseURL(_companyIntegration: MJCompanyIntegrationEntity, _auth: EverhourAuthContext): string;
+    /**
+     * Plain fetch, with one deliberate URL normalization: `%3A` is decoded back to `:`.
+     *
+     * Every Everhour project and task id contains a colon (`as:1234567890`), and the base substitutes
+     * template variables with encodeURIComponent, which turns the id in `/projects/{project_id}/tasks`
+     * into `as%3A1234567890`. That substitution helper is private, so the path cannot be fixed where it
+     * is built — this is the one seam that sees the final URL. A colon is a legal character in both a
+     * path segment and a query value under RFC 3986, so decoding it is safe everywhere in the URL, and
+     * it removes any dependence on Everhour's router happening to percent-decode before matching.
+     */
+    protected MakeHTTPRequest(_auth: EverhourAuthContext, url: string, method: string, headers: Record<string, string>, body?: unknown): Promise<RESTResponse>;
+    /**
+     * Everhour returns bare JSON arrays with no envelope — there is no data key to unwrap, which is
+     * why every object declares an empty ResponseDataKey.
+     */
+    protected NormalizeResponse(rawBody: unknown, responseDataKey: string | null): Record<string, unknown>[];
+    /**
+     * A bare array carries no next-page marker, so the only available signal is whether the page came
+     * back full. A short page is the last page; a full page means ask for another.
+     *
+     * That inference is safe against the one case it could loop on — an endpoint that silently ignores
+     * `page` and re-serves page one forever — because the base compares the first record of
+     * consecutive pages and stops on a repeat. This matters concretely: Everhour documents `page` on
+     * `/projects/{id}/tasks` and `/team/time` but NOT on `/projects`, where only `limit` is listed.
+     * The parameter does work there (the legacy driver paged projects in production for years), but
+     * the guarantee that a doc omission cannot become an infinite loop comes from that guard, not from
+     * the vendor.
+     */
+    protected ExtractPaginationInfo(rawBody: unknown, paginationType: PaginationType, currentPage: number, _currentOffset: number, pageSize: number): PaginationState;
+    /**
+     * Everhour spells its page size `limit`, where the base's PageNumber case emits `pageSize`. An
+     * unknown parameter is not an error Everhour reports — it falls back to its own default page size,
+     * so the fetch would quietly run at the wrong width and, worse, `ExtractPaginationInfo` would then
+     * be comparing the returned count against a page size that was never requested and could end the
+     * object early. This override is the one place that mismatch is fixed.
+     *
+     * `limit` is also clamped to the documented per-endpoint maximum: Everhour rejects an over-large
+     * `limit` on tasks (250 max) rather than silently capping it.
+     */
+    protected BuildPaginatedURL(basePath: string, obj: MJIntegrationObjectEntity, page: number, offset: number, cursor?: string, effectivePageSize?: number): string;
+    /**
+     * Adds the incremental date window, which is per-run rather than per-object and so cannot be
+     * declared metadata.
+     *
+     * `from` is deliberately backdated by a lookback window (default 7 days, overridable per tenant as
+     * `Configuration.lookbackDays`). A time record's `date` is the day the work happened, but the
+     * record itself stays editable — comments, durations and invoiced/locked flags change after the
+     * fact. Filtering strictly from the high-water mark would land those edits never. Re-reading a
+     * week of days costs nothing beyond the read: records upsert by id, and the engine's content-hash
+     * prefetch turns unchanged ones into zero writes.
+     *
+     * `to` is sent explicitly rather than left to Everhour's default, so the window is one this
+     * connector defined instead of one the vendor may redefine.
+     */
+    protected AppendDefaultQueryParams(url: string, obj: MJIntegrationObjectEntity): string;
+    /** Today in UTC as `YYYY-MM-DD`. Isolated so tests can pin the clock. */
+    protected Today(): string;
+    /**
+     * Delegates the whole fetch to the base (pagination, parent iteration, batching) and adds only
+     * what the base has no way to know: the per-run date window, and the new watermark.
+     *
+     * The watermark advances to the maximum `date` actually observed, never to the wall clock. A
+     * clock-based watermark would claim coverage of days whose records had not been fetched yet when
+     * the run ended.
+     */
+    FetchChanges(ctx: FetchContext): Promise<FetchBatchResult>;
+    /**
+     * Flattens Everhour's nested sub-objects onto the declared columns.
+     *
+     * Everhour returns compound values as objects (`billing: {type,fee}`, `estimate: {total,type}`,
+     * `task: {id,name,…}`) and open-ended ones as arrays or maps (`labels`, `users`, per-integration
+     * `attributes`/`metrics`). The sync engine maps a declared column only from a top-level key of the
+     * same name, so without this every one of those columns lands null while the run reports success.
+     * The base's applyTransformPreservingKeys keeps the original nested keys alongside these, so
+     * full-record custom-column capture still sees everything Everhour sent.
+     *
+     * The open-ended ones are serialized rather than declared: `attributes` and `metrics` are whatever
+     * the upstream integration defines per workspace, `userRateOverrides` is keyed by user id, and
+     * `labels`/`users` are unbounded. None can be a column in a fixed catalog, so each lands as JSON
+     * for downstream projection — an empty collection as null rather than "[]", so "no labels" and
+     * "not returned" read the same downstream.
+     */
+    protected TransformRecord(raw: Record<string, unknown>, _obj: MJIntegrationObjectEntity, _fields: MJIntegrationObjectFieldEntity[]): Record<string, unknown>;
+    /**
+     * Probes `/users/me`. Unlike a workspace-scoped vendor there is no second thing to verify: the API
+     * key carries the team, so a key that authenticates is a key that can see the team's data. A 401
+     * is reported distinctly from any other failure because it is the only one the tenant can fix by
+     * re-entering a credential.
+     */
+    TestConnection(companyIntegration: MJCompanyIntegrationEntity, contextUser: UserInfo): Promise<ConnectionTestResult>;
+    /**
+     * Resolves the API key from the linked Credential entity, falling back to the
+     * CompanyIntegration.Configuration JSON.
+     *
+     * CompanyIntegration.APIKey is deliberately NOT read — which is a change from the legacy driver,
+     * whose `connect()` took the key straight off that column. It is not a decrypt-on-read column, so
+     * a value written through mj-sync encryption comes back as the literal `$ENC$…` string and would
+     * be sent to Everhour verbatim, authenticating as nobody while looking configured.
+     */
+    private LoadCredentials;
+    private LoadFromCredentialEntity;
+    /** Parses a credential/Configuration JSON blob, tolerating the usual casing/naming aliases. */
+    private ParseCredentialJson;
+}
+/** Auth context: Everhour's single API key, which carries the team scope by itself. */
+interface EverhourAuthContext extends RESTAuthContext {
+    ApiKey: string;
+}
+/**
+ * Undoes percent-encoding of the colon.
+ *
+ * Exported for the tests that pin this behaviour: it is the difference between
+ * `/projects/as%3A123/tasks` and `/projects/as:123/tasks`, and every Everhour project id has a colon
+ * in it. Only `%3A`/`%3a` is touched — this is not a general URL decode, which would corrupt any
+ * legitimately encoded `&`, `=` or space in a query value.
+ */
+export declare function restoreColons(url: string): string;
+/**
+ * Serializes an unbounded collection to JSON, or null when it is empty or absent.
+ *
+ * Empty collapses to null so that "the project has no assigned users" and "Everhour did not return
+ * users" are the same landed value — a literal `"[]"` would read as data downstream and would also
+ * change the record's content hash the first time the vendor started omitting an empty array.
+ */
+export declare function serializeCollection(value: unknown): string | null;
+/**
+ * The source-platform prefix of an Everhour id (`as:1234` → `as`), or null when the id carries none.
+ *
+ * Deliberately narrow: two characters followed by a colon is the documented shape of every platform
+ * code Everhour publishes (`as`, `ev`, `b2`, `b3`, `pv`, `gh`, `in`, `tr`, `jr` — note two of them
+ * contain a digit, hence alphanumeric rather than alphabetic). Anything else is left alone rather than
+ * guessed at, so a future id format cannot silently produce a garbage platform value.
+ */
+export declare function platformFromID(id: unknown): string | null;
+/**
+ * The `from` date for an incremental fetch: the watermark backdated by the lookback window, clamped
+ * so it can never land in the future.
+ *
+ * With no watermark yet — a first run — this returns the epoch bound rather than `today - lookback`,
+ * so the initial sync pulls the full history. Getting that backwards would make a first sync look
+ * complete while holding one week of data.
+ */
+export declare function incrementalFromDate(watermark: string | null, lookbackDays: number, today: string): string;
+/**
+ * Reads `lookbackDays` out of an IntegrationObject's Configuration JSON, falling back to the default.
+ *
+ * A non-numeric, negative or absurd value falls back rather than throwing: this is tenant-editable
+ * configuration, and a typo in it should not take the object's sync down.
+ */
+export declare function parseLookbackDays(configuration: string | null): number;
+/**
+ * The highest `date` across a batch, or null when the batch moves it nowhere.
+ *
+ * Compared as strings, which is correct for the fixed-width `YYYY-MM-DD` form Everhour emits. The
+ * previous watermark seeds the comparison so a batch containing only older records — which the
+ * lookback window guarantees on every incremental run — can never drag the high-water mark backwards.
+ */
+export declare function maxDate(records: ReadonlyArray<{
+    Fields: Record<string, unknown>;
+}>, previous: string | null): string | null;
+export {};

package/dist/EverhourConnector.js

@@ -0,0 +1,543 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { RegisterClass } from '@memberjunction/global';
+import { Metadata } from '@memberjunction/core';
+import { BaseIntegrationConnector, BaseRESTIntegrationConnector, } from '@memberjunction/integration-engine';
+import { z } from 'zod';
+/**
+ * Everhour time-tracking connector (REST API v1.2, read-only).
+ *
+ * ── Everhour ids carry a platform prefix, and that is the whole `as:` story ──
+ * An Everhour project id is literally `as:1234567890` (Asana-sourced), `jr:…` (Jira), `ev:…` (native),
+ * and so on — the prefix is part of the vendor's own identifier, documented in its Project schema, not
+ * an addressing convention a caller adds. The legacy AIDP driver looked like it was doing something
+ * exotic (`/projects/as:${externalId}/tasks`) only because it had *stripped* the prefix on the way in,
+ * with `id.slice(3)`, to make the remainder match an Asana gid — then had to put it back to make the
+ * next call. This connector keeps every id exactly as Everhour issued it, so the prefix never has to
+ * be reconstructed and the connector never has to know that some Everhour workspaces are backed by
+ * Asana. Nothing here is Asana-aware.
+ *
+ * ── Vendor units are preserved, not converted ──
+ * Everhour reports money in cents and durations in seconds. The legacy driver divided fees, rates and
+ * budgets by 100 on the way into AIDP's schema; that is a presentation choice belonging to whoever
+ * consumes the data, and doing it here would make the landed value disagree with what the API returned
+ * and with what Everhour's own UI reports. Every amount lands in the vendor's unit and every field
+ * description names that unit.
+ *
+ * ── Time records come from the team-wide door, not per project ──
+ * The legacy driver read time one project at a time (`/projects/{id}/time`), which is an N+1 over the
+ * project list and, at Everhour's ~20 requests / 10 seconds, the dominant cost of a run. Everhour also
+ * publishes `/team/time?from=&to=`, which returns the same records for the whole team in one paged
+ * stream. TimeRecords therefore has no parent door at all, and `from`/`to` gives the incremental
+ * filter directly.
+ *
+ * ── Tasks is a templated child door ──
+ * Everhour exposes no unfiltered team-wide task listing (`/tasks/search` requires a search term), so
+ * tasks are addressable only per project. Tasks declares `Configuration.parentObjectName: "Projects"`
+ * so the engine iterates the already-synced projects; without that declaration it would fetch zero
+ * rows and the run would still report success.
+ */
+// Primary key follows the catalog convention (className == npm package name; see
+// scripts/build-connectors-catalog.mjs) — instance discovery reports the package name, so a bare
+// class-symbol key would never match in the catalog. The bare symbol stays registered as an alias.
+let EverhourConnector = class EverhourConnector extends BaseRESTIntegrationConnector {
+    constructor() {
+        super(...arguments);
+        /**
+         * The watermark for the object currently being fetched, stashed by FetchChanges so
+         * AppendDefaultQueryParams — which the base calls per page and which receives no context — can
+         * apply the `from`/`to` window. Cleared on the way out so a non-incremental object can never
+         * inherit the previous object's filter.
+         */
+        this.currentWatermark = null;
+    }
+    /** Verbatim three-way invariant name: ClassName / IntegrationName getter / MJ: Integrations.Name. */
+    get IntegrationName() {
+        return 'Everhour';
+    }
+    /**
+     * The only incremental object is TimeRecords, watermarked on `date`, and the watermark only ever
+     * advances to the maximum date actually observed. Records are never re-dated backwards by Everhour
+     * — an edit changes `time`/`comment`, not which day the work happened — so the high-water mark is
+     * monotonic even though the records behind it are mutable. The lookback window below is what
+     * covers those mutations.
+     */
+    get MonotonicWatermark() {
+        return true;
+    }
+    /**
+     * Everhour's list endpoints document no ordering guarantee and offer no sort parameter, so there
+     * is no key a keyset resume could resume against. Paging is `page`/`limit`.
+     */
+    StableOrderingKey(_objectName) {
+        return null;
+    }
+    // ─── Auth + transport (BaseRESTIntegrationConnector abstracts) ────
+    /**
+     * Resolves the API key. Everhour has no separate tenant identifier: the key *is* the team scope,
+     * which is why nothing here reads ExternalSystemID and why there is no workspace parameter on any
+     * request.
+     */
+    async Authenticate(companyIntegration, contextUser) {
+        const apiKey = await this.LoadCredentials(companyIntegration, contextUser);
+        return { ApiKey: apiKey };
+    }
+    BuildHeaders(auth) {
+        return {
+            'X-Api-Key': auth.ApiKey,
+            'Accept': 'application/json',
+            // Everhour describes its API as BETA and, absent this header, serves whatever version is
+            // newest — so an unannounced vendor release could reshape responses under a catalog that
+            // was validated against 1.2. Pinning turns that from a silent shape change into a
+            // deliberate, reviewable version bump here.
+            'X-Accept-Version': EVERHOUR_API_VERSION,
+        };
+    }
+    GetBaseURL(_companyIntegration, _auth) {
+        return EVERHOUR_API_BASE;
+    }
+    /**
+     * Plain fetch, with one deliberate URL normalization: `%3A` is decoded back to `:`.
+     *
+     * Every Everhour project and task id contains a colon (`as:1234567890`), and the base substitutes
+     * template variables with encodeURIComponent, which turns the id in `/projects/{project_id}/tasks`
+     * into `as%3A1234567890`. That substitution helper is private, so the path cannot be fixed where it
+     * is built — this is the one seam that sees the final URL. A colon is a legal character in both a
+     * path segment and a query value under RFC 3986, so decoding it is safe everywhere in the URL, and
+     * it removes any dependence on Everhour's router happening to percent-decode before matching.
+     */
+    async MakeHTTPRequest(_auth, url, method, headers, body) {
+        const init = { method, headers };
+        if (body !== undefined && method !== 'GET' && method !== 'HEAD') {
+            init.body = typeof body === 'string' ? body : JSON.stringify(body);
+            init.headers['Content-Type'] = 'application/json';
+        }
+        const response = await fetch(restoreColons(url), init);
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => { responseHeaders[key.toLowerCase()] = value; });
+        const text = await response.text();
+        let parsed = text;
+        const contentType = responseHeaders['content-type'] ?? '';
+        if (contentType.includes('json') || (text.length > 0 && (text[0] === '{' || text[0] === '['))) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = text;
+            }
+        }
+        return { Status: response.status, Body: parsed, Headers: responseHeaders };
+    }
+    /**
+     * Everhour returns bare JSON arrays with no envelope — there is no data key to unwrap, which is
+     * why every object declares an empty ResponseDataKey.
+     */
+    NormalizeResponse(rawBody, responseDataKey) {
+        if (responseDataKey && isRecord(rawBody)) {
+            const inner = rawBody[responseDataKey];
+            if (Array.isArray(inner))
+                return inner.filter(isRecord);
+            if (isRecord(inner))
+                return [inner];
+        }
+        if (Array.isArray(rawBody))
+            return rawBody.filter(isRecord);
+        if (isRecord(rawBody))
+            return [rawBody];
+        return [];
+    }
+    /**
+     * A bare array carries no next-page marker, so the only available signal is whether the page came
+     * back full. A short page is the last page; a full page means ask for another.
+     *
+     * That inference is safe against the one case it could loop on — an endpoint that silently ignores
+     * `page` and re-serves page one forever — because the base compares the first record of
+     * consecutive pages and stops on a repeat. This matters concretely: Everhour documents `page` on
+     * `/projects/{id}/tasks` and `/team/time` but NOT on `/projects`, where only `limit` is listed.
+     * The parameter does work there (the legacy driver paged projects in production for years), but
+     * the guarantee that a doc omission cannot become an infinite loop comes from that guard, not from
+     * the vendor.
+     */
+    ExtractPaginationInfo(rawBody, paginationType, currentPage, _currentOffset, pageSize) {
+        if (paginationType !== 'PageNumber')
+            return { HasMore: false };
+        const count = Array.isArray(rawBody) ? rawBody.length : 0;
+        if (pageSize > 0 && count >= pageSize) {
+            return { HasMore: true, NextPage: currentPage + 1 };
+        }
+        return { HasMore: false };
+    }
+    /**
+     * Everhour spells its page size `limit`, where the base's PageNumber case emits `pageSize`. An
+     * unknown parameter is not an error Everhour reports — it falls back to its own default page size,
+     * so the fetch would quietly run at the wrong width and, worse, `ExtractPaginationInfo` would then
+     * be comparing the returned count against a page size that was never requested and could end the
+     * object early. This override is the one place that mismatch is fixed.
+     *
+     * `limit` is also clamped to the documented per-endpoint maximum: Everhour rejects an over-large
+     * `limit` on tasks (250 max) rather than silently capping it.
+     */
+    BuildPaginatedURL(basePath, obj, page, offset, cursor, effectivePageSize) {
+        if (obj.PaginationType !== 'PageNumber') {
+            return super.BuildPaginatedURL(basePath, obj, page, offset, cursor, effectivePageSize);
+        }
+        const max = MAX_PAGE_SIZE_BY_OBJECT[obj.Name] ?? DEFAULT_MAX_PAGE_SIZE;
+        const requested = effectivePageSize ?? obj.DefaultPageSize ?? max;
+        const limit = Math.min(max, Math.max(1, requested));
+        const separator = basePath.includes('?') ? '&' : '?';
+        return `${basePath}${separator}page=${page}&limit=${limit}`;
+    }
+    /**
+     * Adds the incremental date window, which is per-run rather than per-object and so cannot be
+     * declared metadata.
+     *
+     * `from` is deliberately backdated by a lookback window (default 7 days, overridable per tenant as
+     * `Configuration.lookbackDays`). A time record's `date` is the day the work happened, but the
+     * record itself stays editable — comments, durations and invoiced/locked flags change after the
+     * fact. Filtering strictly from the high-water mark would land those edits never. Re-reading a
+     * week of days costs nothing beyond the read: records upsert by id, and the engine's content-hash
+     * prefetch turns unchanged ones into zero writes.
+     *
+     * `to` is sent explicitly rather than left to Everhour's default, so the window is one this
+     * connector defined instead of one the vendor may redefine.
+     */
+    AppendDefaultQueryParams(url, obj) {
+        let out = super.AppendDefaultQueryParams(url, obj);
+        if (obj.SupportsIncrementalSync) {
+            const today = this.Today();
+            const lookbackDays = parseLookbackDays(obj.Configuration);
+            out = appendParam(out, 'from', incrementalFromDate(this.currentWatermark, lookbackDays, today));
+            out = appendParam(out, 'to', today);
+        }
+        return out;
+    }
+    /** Today in UTC as `YYYY-MM-DD`. Isolated so tests can pin the clock. */
+    Today() {
+        return new Date().toISOString().slice(0, 10);
+    }
+    // ─── Fetch ───────────────────────────────────────────────────────
+    /**
+     * Delegates the whole fetch to the base (pagination, parent iteration, batching) and adds only
+     * what the base has no way to know: the per-run date window, and the new watermark.
+     *
+     * The watermark advances to the maximum `date` actually observed, never to the wall clock. A
+     * clock-based watermark would claim coverage of days whose records had not been fetched yet when
+     * the run ended.
+     */
+    async FetchChanges(ctx) {
+        this.currentWatermark = ctx.WatermarkValue;
+        try {
+            const result = await super.FetchChanges(ctx);
+            const newWatermark = maxDate(result.Records, ctx.WatermarkValue);
+            return newWatermark ? { ...result, NewWatermarkValue: newWatermark } : result;
+        }
+        finally {
+            this.currentWatermark = null;
+        }
+    }
+    /**
+     * Flattens Everhour's nested sub-objects onto the declared columns.
+     *
+     * Everhour returns compound values as objects (`billing: {type,fee}`, `estimate: {total,type}`,
+     * `task: {id,name,…}`) and open-ended ones as arrays or maps (`labels`, `users`, per-integration
+     * `attributes`/`metrics`). The sync engine maps a declared column only from a top-level key of the
+     * same name, so without this every one of those columns lands null while the run reports success.
+     * The base's applyTransformPreservingKeys keeps the original nested keys alongside these, so
+     * full-record custom-column capture still sees everything Everhour sent.
+     *
+     * The open-ended ones are serialized rather than declared: `attributes` and `metrics` are whatever
+     * the upstream integration defines per workspace, `userRateOverrides` is keyed by user id, and
+     * `labels`/`users` are unbounded. None can be a column in a fixed catalog, so each lands as JSON
+     * for downstream projection — an empty collection as null rather than "[]", so "no labels" and
+     * "not returned" read the same downstream.
+     */
+    TransformRecord(raw, _obj, _fields) {
+        const out = { ...raw };
+        for (const [parent, key, target] of NESTED_SCALARS) {
+            const value = raw[parent];
+            if (isRecord(value))
+                out[target] = value[key] ?? null;
+            else if (value === null)
+                out[target] = null;
+        }
+        for (const [source, target] of JSON_COLLECTIONS) {
+            if (source in raw)
+                out[target] = serializeCollection(raw[source]);
+        }
+        // The id prefix is the vendor's source-platform discriminator (`as` Asana, `jr` Jira, `ev`
+        // native Everhour, …) and is the same value the `platform` filter on /projects accepts. It is
+        // promoted to its own column because filtering landed rows by source is otherwise a substring
+        // match on the primary key.
+        const platform = platformFromID(raw['id']);
+        if (platform !== null)
+            out['platform'] = platform;
+        return out;
+    }
+    // ─── Connection test ─────────────────────────────────────────────
+    /**
+     * Probes `/users/me`. Unlike a workspace-scoped vendor there is no second thing to verify: the API
+     * key carries the team, so a key that authenticates is a key that can see the team's data. A 401
+     * is reported distinctly from any other failure because it is the only one the tenant can fix by
+     * re-entering a credential.
+     */
+    async TestConnection(companyIntegration, contextUser) {
+        try {
+            const auth = await this.Authenticate(companyIntegration, contextUser);
+            const headers = this.BuildHeaders(auth);
+            const me = await this.MakeHTTPRequest(auth, `${EVERHOUR_API_BASE}/users/me`, 'GET', headers);
+            if (me.Status === 401) {
+                return { Success: false, Message: 'Everhour rejected the API key (HTTP 401).' };
+            }
+            if (me.Status >= 400) {
+                return { Success: false, Message: `Everhour /users/me returned HTTP ${me.Status}.` };
+            }
+            const body = isRecord(me.Body) ? me.Body : {};
+            const who = stringOrNull(body['name'])
+                ?? stringOrNull(body['email'])
+                ?? (body['id'] != null ? String(body['id']) : 'unknown user');
+            return {
+                Success: true,
+                Message: `Connected to Everhour as ${who}.`,
+                ServerVersion: EVERHOUR_API_VERSION,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { Success: false, Message: `Everhour connection error: ${message}` };
+        }
+    }
+    // ─── Credential resolution ───────────────────────────────────────
+    /**
+     * Resolves the API key from the linked Credential entity, falling back to the
+     * CompanyIntegration.Configuration JSON.
+     *
+     * CompanyIntegration.APIKey is deliberately NOT read — which is a change from the legacy driver,
+     * whose `connect()` took the key straight off that column. It is not a decrypt-on-read column, so
+     * a value written through mj-sync encryption comes back as the literal `$ENC$…` string and would
+     * be sent to Everhour verbatim, authenticating as nobody while looking configured.
+     */
+    async LoadCredentials(companyIntegration, contextUser) {
+        let apiKey;
+        if (companyIntegration.CredentialID) {
+            apiKey = await this.LoadFromCredentialEntity(companyIntegration.CredentialID, contextUser) ?? undefined;
+        }
+        if (!apiKey && companyIntegration.Configuration) {
+            apiKey = this.ParseCredentialJson(companyIntegration.Configuration) ?? undefined;
+        }
+        if (!apiKey) {
+            throw new Error('No Everhour credential found — link an "API Key" credential holding the Everhour API ' +
+                'key, or supply one as "apiKey" in the CompanyIntegration.Configuration JSON.');
+        }
+        return apiKey;
+    }
+    async LoadFromCredentialEntity(credentialID, contextUser, provider) {
+        const md = provider ?? new Metadata();
+        const credential = await md.GetEntityObject('MJ: Credentials', contextUser);
+        const loaded = await credential.Load(credentialID);
+        if (!loaded || !credential.Values)
+            return null;
+        return this.ParseCredentialJson(credential.Values);
+    }
+    /** Parses a credential/Configuration JSON blob, tolerating the usual casing/naming aliases. */
+    ParseCredentialJson(json) {
+        try {
+            const result = EverhourCredentialSchema.safeParse(JSON.parse(json));
+            if (!result.success)
+                return null;
+            const p = result.data;
+            const key = p.apiKey ?? p.ApiKey ?? p.APIKey ?? p.key ?? p.Token ?? p.token;
+            return key != null && String(key).length > 0 ? String(key) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+};
+EverhourConnector = __decorate([
+    RegisterClass(BaseIntegrationConnector, '@memberjunction/connector-everhour'),
+    RegisterClass(BaseIntegrationConnector, 'EverhourConnector')
+], EverhourConnector);
+export { EverhourConnector };
+// ─── Module-level constants, types + helpers (mechanism, NOT a catalog) ───
+/** Everhour's REST base. Single-tenant SaaS with no per-customer host, so there is nothing to configure. */
+const EVERHOUR_API_BASE = 'https://api.everhour.com';
+/** The API version this catalog was validated against, pinned via X-Accept-Version. */
+const EVERHOUR_API_VERSION = '1.2';
+/**
+ * Documented per-endpoint `limit` maxima. Tasks is the only one Everhour states outright ("250 max");
+ * the others use the value the docs show, which is the conservative reading. Time records accept up to
+ * 50000, far above any batch this connector would ask for, so the lower cap costs nothing and keeps a
+ * runaway page size from turning into a multi-megabyte response.
+ */
+const MAX_PAGE_SIZE_BY_OBJECT = {
+    Projects: 100,
+    Tasks: 250,
+    TimeRecords: 1000,
+};
+const DEFAULT_MAX_PAGE_SIZE = 100;
+/** `[nested object, key within it, flat column]` — Everhour's compound scalars. */
+const NESTED_SCALARS = [
+    ['billing', 'type', 'billing_type'],
+    ['billing', 'fee', 'billing_fee'],
+    ['rate', 'type', 'rate_type'],
+    ['rate', 'rate', 'rate_rate'],
+    ['budget', 'type', 'budget_type'],
+    ['budget', 'budget', 'budget_budget'],
+    ['budget', 'period', 'budget_period'],
+    ['budget', 'progress', 'budget_progress'],
+    ['budget', 'timeProgress', 'budget_time_progress'],
+    ['budget', 'expenseProgress', 'budget_expense_progress'],
+    ['budget', 'appliedFrom', 'budget_applied_from'],
+    ['budget', 'threshold', 'budget_threshold'],
+    ['budget', 'disallowOverbudget', 'budget_disallow_overbudget'],
+    ['budget', 'excludeUnbillableTime', 'budget_exclude_unbillable_time'],
+    ['budget', 'excludeExpenses', 'budget_exclude_expenses'],
+    ['estimate', 'total', 'estimate_total'],
+    ['estimate', 'type', 'estimate_type'],
+    ['time', 'total', 'time_total'],
+    ['task', 'id', 'task_id'],
+    ['task', 'name', 'task_name'],
+];
+/** Unbounded / workspace-defined collections → the JSON column each is serialized onto. */
+const JSON_COLLECTIONS = [
+    ['users', 'users_json'],
+    ['projects', 'project_ids_json'],
+    ['labels', 'labels_json'],
+    ['attributes', 'attributes_json'],
+    ['metrics', 'metrics_json'],
+    ['history', 'history_json'],
+];
+const EverhourCredentialSchema = z.object({
+    apiKey: z.string().optional(),
+    ApiKey: z.string().optional(),
+    APIKey: z.string().optional(),
+    key: z.string().optional(),
+    Token: z.string().optional(),
+    token: z.string().optional(),
+}).passthrough();
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function stringOrNull(v) {
+    return typeof v === 'string' && v.length > 0 ? v : null;
+}
+function appendParam(url, key, value) {
+    const separator = url.includes('?') ? '&' : '?';
+    return `${url}${separator}${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+}
+/**
+ * Undoes percent-encoding of the colon.
+ *
+ * Exported for the tests that pin this behaviour: it is the difference between
+ * `/projects/as%3A123/tasks` and `/projects/as:123/tasks`, and every Everhour project id has a colon
+ * in it. Only `%3A`/`%3a` is touched — this is not a general URL decode, which would corrupt any
+ * legitimately encoded `&`, `=` or space in a query value.
+ */
+export function restoreColons(url) {
+    return url.replace(/%3A/gi, ':');
+}
+/**
+ * Serializes an unbounded collection to JSON, or null when it is empty or absent.
+ *
+ * Empty collapses to null so that "the project has no assigned users" and "Everhour did not return
+ * users" are the same landed value — a literal `"[]"` would read as data downstream and would also
+ * change the record's content hash the first time the vendor started omitting an empty array.
+ */
+export function serializeCollection(value) {
+    if (value == null)
+        return null;
+    if (Array.isArray(value))
+        return value.length > 0 ? JSON.stringify(value) : null;
+    if (typeof value === 'object') {
+        return Object.keys(value).length > 0 ? JSON.stringify(value) : null;
+    }
+    return null;
+}
+/**
+ * The source-platform prefix of an Everhour id (`as:1234` → `as`), or null when the id carries none.
+ *
+ * Deliberately narrow: two characters followed by a colon is the documented shape of every platform
+ * code Everhour publishes (`as`, `ev`, `b2`, `b3`, `pv`, `gh`, `in`, `tr`, `jr` — note two of them
+ * contain a digit, hence alphanumeric rather than alphabetic). Anything else is left alone rather than
+ * guessed at, so a future id format cannot silently produce a garbage platform value.
+ */
+export function platformFromID(id) {
+    if (typeof id !== 'string')
+        return null;
+    const match = /^([a-z][a-z0-9]):/.exec(id);
+    return match ? match[1] : null;
+}
+/**
+ * The start date for a first, unwatermarked sync. Everhour launched well after this, and its API
+ * rejects no date this old, so it is "everything" expressed as a bound the vendor will accept —
+ * `from` is not optional in the way `to` is, and omitting it lets Everhour choose the window instead.
+ */
+const EVERHOUR_EPOCH_DATE = '2010-01-01';
+/** Default days of already-synced history to re-read on each incremental run. */
+const DEFAULT_LOOKBACK_DAYS = 7;
+/** A lookback beyond this is indistinguishable from a full re-sync; treat it as a misconfiguration. */
+const MAX_LOOKBACK_DAYS = 3650;
+/**
+ * The `from` date for an incremental fetch: the watermark backdated by the lookback window, clamped
+ * so it can never land in the future.
+ *
+ * With no watermark yet — a first run — this returns the epoch bound rather than `today - lookback`,
+ * so the initial sync pulls the full history. Getting that backwards would make a first sync look
+ * complete while holding one week of data.
+ */
+export function incrementalFromDate(watermark, lookbackDays, today) {
+    if (!watermark)
+        return EVERHOUR_EPOCH_DATE;
+    const base = Date.parse(`${watermark.slice(0, 10)}T00:00:00Z`);
+    if (Number.isNaN(base))
+        return EVERHOUR_EPOCH_DATE;
+    const shifted = new Date(base - lookbackDays * 86_400_000).toISOString().slice(0, 10);
+    return shifted > today ? today : shifted;
+}
+/**
+ * Reads `lookbackDays` out of an IntegrationObject's Configuration JSON, falling back to the default.
+ *
+ * A non-numeric, negative or absurd value falls back rather than throwing: this is tenant-editable
+ * configuration, and a typo in it should not take the object's sync down.
+ */
+export function parseLookbackDays(configuration) {
+    if (!configuration)
+        return DEFAULT_LOOKBACK_DAYS;
+    try {
+        const parsed = JSON.parse(configuration);
+        if (!isRecord(parsed))
+            return DEFAULT_LOOKBACK_DAYS;
+        const value = parsed['lookbackDays'];
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return DEFAULT_LOOKBACK_DAYS;
+        if (value < 0 || value > MAX_LOOKBACK_DAYS)
+            return DEFAULT_LOOKBACK_DAYS;
+        return Math.floor(value);
+    }
+    catch {
+        return DEFAULT_LOOKBACK_DAYS;
+    }
+}
+/**
+ * The highest `date` across a batch, or null when the batch moves it nowhere.
+ *
+ * Compared as strings, which is correct for the fixed-width `YYYY-MM-DD` form Everhour emits. The
+ * previous watermark seeds the comparison so a batch containing only older records — which the
+ * lookback window guarantees on every incremental run — can never drag the high-water mark backwards.
+ */
+export function maxDate(records, previous) {
+    let best = previous;
+    for (const record of records) {
+        const value = record.Fields['date'];
+        if (typeof value !== 'string' || value.length === 0)
+            continue;
+        if (best === null || value > best)
+            best = value;
+    }
+    return best === previous ? null : best;
+}
+//# sourceMappingURL=EverhourConnector.js.map

package/dist/EverhourConnector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EverhourConnector.js","sourceRoot":"","sources":["../src/EverhourConnector.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './EverhourConnector.js';
+/** Open App bootstrap entry: importing this module ran the connector's @RegisterClass decorator;
+ *  this no-op satisfies the loader's required startupExport and forces the import at MJAPI boot. */
+export declare function registerConnector(): void;

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './EverhourConnector.js';
+/** Open App bootstrap entry: importing this module ran the connector's @RegisterClass decorator;
+ *  this no-op satisfies the loader's required startupExport and forces the import at MJAPI boot. */
+export function registerConnector() { }
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AAEvC;oGACoG;AACpG,MAAM,UAAU,iBAAiB,KAAiD,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@memberjunction/connector-everhour",
+  "version": "0.2.0",
+  "description": "MemberJunction Everhour connector.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "build": "tsc && tsc-alias -f",
+    "test": "vitest run"
+  },
+  "author": "MemberJunction.com",
+  "license": "ISC",
+  "peerDependencies": {
+    "@memberjunction/core": ">=5.43.0 <6.0.0",
+    "@memberjunction/core-entities": ">=5.43.0 <6.0.0",
+    "@memberjunction/global": ">=5.43.0 <6.0.0",
+    "@memberjunction/integration-engine": ">=5.43.0 <6.0.0"
+  },
+  "dependencies": {
+    "zod": "~3.24.4"
+  },
+  "devDependencies": {
+    "@memberjunction/core": "^5.43.0",
+    "@memberjunction/core-entities": "^5.43.0",
+    "@memberjunction/global": "^5.43.0",
+    "@memberjunction/integration-engine": "^5.43.0",
+    "@types/node": "24.10.11",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MemberJunction/Integrations"
+  }
+}