@centrali-io/centrali-sdk 5.3.0 → 5.5.0

package/dist/query-types.js

@@ -0,0 +1,137 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// AUTO-GENERATED — DO NOT EDIT BY HAND.
+//
+// Source: services/backend/shared/query/src/types.ts (@centrali/query)
+// Regenerate: `npm run sync:query-types` (also runs on prebuild).
+//
+// The shared package is the single source of truth for canonical query types.
+// This file is a types-only port so the published SDK stays a single npm
+// install. See CEN-1194 for the alignment, CEN-1202 for runtime bundling.
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORDS_PAGE_MAX_LIMIT = exports.RECORDS_PAGE_DEFAULT_LIMIT = exports.OPERATOR_METADATA = exports.CANONICAL_OPERATORS = void 0;
+exports.operatorsForFieldType = operatorsForFieldType;
+exports.CANONICAL_OPERATORS = [
+    'eq',
+    'ne',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'in',
+    'nin',
+    'contains',
+    'startsWith',
+    'endsWith',
+    'hasAny',
+    'hasAll',
+    'exists',
+];
+exports.OPERATOR_METADATA = {
+    eq: {
+        operator: 'eq',
+        label: 'equals',
+        shortLabel: '=',
+        valueShape: 'scalar',
+        applicableTypes: ['any'],
+    },
+    ne: {
+        operator: 'ne',
+        label: 'not equals',
+        shortLabel: '≠',
+        valueShape: 'scalar',
+        applicableTypes: ['any'],
+    },
+    gt: {
+        operator: 'gt',
+        label: 'greater than',
+        shortLabel: '>',
+        valueShape: 'scalar',
+        applicableTypes: ['number', 'datetime'],
+    },
+    gte: {
+        operator: 'gte',
+        label: 'greater or equal',
+        shortLabel: '≥',
+        valueShape: 'scalar',
+        applicableTypes: ['number', 'datetime'],
+    },
+    lt: {
+        operator: 'lt',
+        label: 'less than',
+        shortLabel: '<',
+        valueShape: 'scalar',
+        applicableTypes: ['number', 'datetime'],
+    },
+    lte: {
+        operator: 'lte',
+        label: 'less or equal',
+        shortLabel: '≤',
+        valueShape: 'scalar',
+        applicableTypes: ['number', 'datetime'],
+    },
+    in: {
+        operator: 'in',
+        label: 'in',
+        valueShape: 'array',
+        applicableTypes: ['string', 'number', 'datetime'],
+    },
+    nin: {
+        operator: 'nin',
+        label: 'not in',
+        valueShape: 'array',
+        applicableTypes: ['string', 'number', 'datetime'],
+    },
+    contains: {
+        operator: 'contains',
+        label: 'contains',
+        valueShape: 'scalar',
+        applicableTypes: ['string'],
+    },
+    startsWith: {
+        operator: 'startsWith',
+        label: 'starts with',
+        valueShape: 'scalar',
+        applicableTypes: ['string'],
+    },
+    endsWith: {
+        operator: 'endsWith',
+        label: 'ends with',
+        valueShape: 'scalar',
+        applicableTypes: ['string'],
+    },
+    hasAny: {
+        operator: 'hasAny',
+        label: 'has any of',
+        valueShape: 'array',
+        applicableTypes: ['array'],
+    },
+    hasAll: {
+        operator: 'hasAll',
+        label: 'has all of',
+        valueShape: 'array',
+        applicableTypes: ['array'],
+    },
+    exists: {
+        operator: 'exists',
+        label: 'exists',
+        valueShape: 'boolean',
+        applicableTypes: ['any'],
+    },
+};
+/**
+ * Operators applicable to a given field-type. Used by builder UIs to narrow
+ * the dropdown when the user selects a field; falls back to `any`-applicable
+ * operators when the type is unknown.
+ */
+function operatorsForFieldType(type) {
+    const t = type;
+    return exports.CANONICAL_OPERATORS.map((op) => exports.OPERATOR_METADATA[op]).filter((meta) => meta.applicableTypes.includes('any') || meta.applicableTypes.includes(t));
+}
+/**
+ * Records Phase 1 page defaults (contract §6).
+ * Same default and cap for GET adapter and POST query body.
+ */
+exports.RECORDS_PAGE_DEFAULT_LIMIT = 50;
+exports.RECORDS_PAGE_MAX_LIMIT = 500;

package/dist/scripts/smoke-types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Type-only smoke for the canonical query surface added in 5.5.0 (CEN-1194).
+ *
+ * Runs as part of `npm run build` because it lives in the same project as
+ * `index.ts`. Compiling means the canonical types and new methods type-check
+ * end-to-end. There is no runtime assertion — when the SDK has a real test
+ * harness (separate ticket), these calls will turn into integration tests.
+ *
+ * To run manually:
+ *   npx tsc --noEmit scripts/smoke-types.ts
+ */
+export {};

package/dist/scripts/smoke-types.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Type-only smoke for the canonical query surface added in 5.5.0 (CEN-1194).
+ *
+ * Runs as part of `npm run build` because it lives in the same project as
+ * `index.ts`. Compiling means the canonical types and new methods type-check
+ * end-to-end. There is no runtime assertion — when the SDK has a real test
+ * harness (separate ticket), these calls will turn into integration tests.
+ *
+ * To run manually:
+ *   npx tsc --noEmit scripts/smoke-types.ts
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+// ---- Canonical type ergonomics ----
+const _operators = index_1.CANONICAL_OPERATORS;
+const _defaultLimit = index_1.RECORDS_PAGE_DEFAULT_LIMIT;
+const _maxLimit = index_1.RECORDS_PAGE_MAX_LIMIT;
+const _eqOnly = { eq: 'paid' };
+// Uncommenting the next line MUST fail to compile (exactly-one-operator rule):
+// const _twoOps: FieldCondition = { eq: 'paid', ne: 'cancelled' };
+const _where = {
+    and: [
+        { 'data.status': { eq: 'open' } },
+        { or: [
+                { 'data.amount': { gte: 100 } },
+                { 'data.priority': { eq: 'high' } }
+            ] },
+        { not: { 'data.archived': { eq: true } } }
+    ]
+};
+const _sort = [
+    { field: 'createdAt', direction: 'desc' },
+    { field: 'data.amount', direction: 'asc' }
+];
+const _pageOffset = { limit: 50, offset: 100 };
+const _pageCursor = { limit: 50, cursor: 'abc' };
+// Uncommenting must fail (offset and cursor are mutually exclusive):
+// const _pageBoth: PageClause = { limit: 50, offset: 0, cursor: 'abc' };
+const _select = { fields: ['id', 'data.status', 'data.customer'] };
+const _def = {
+    resource: 'orders',
+    where: _where,
+    sort: _sort,
+    page: _pageOffset,
+    select: _select,
+};
+function exerciseSdk() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const client = new index_1.CentraliSDK({
+            baseUrl: 'http://localhost',
+            workspaceId: 'demo',
+            token: 'test',
+        });
+        // RecordsManager.query → QueryResult<T>
+        const r1 = yield client.records.query('orders', _def);
+        console.log(r1.data.length, r1.meta.limit);
+        // Resource backfill — caller can omit `resource` and we fill it from arg1
+        yield client.records.query('orders', { where: _where });
+        // RecordsManager.test → QueryResult<T>
+        yield client.records.test('orders', { resource: 'orders' });
+        // RecordsManager.list → ApiResponse<T[]> (legacy GET adapter envelope kept)
+        const r2 = yield client.records.list('orders', {
+            'data.status': 'paid',
+            sort: '-createdAt',
+        });
+        console.log(r2.data.length);
+        // RecordsManager.search — text sugar, returns QueryResult<T>
+        const r3 = yield client.records.search('orders', 'urgent shipping', {
+            page: { limit: 25 },
+        });
+        console.log(r3.data, r3.meta.mode);
+        // (Saved-query SDK surface — `client.savedQueries` — is deliberately not
+        // shipped in 5.5.0. The /saved-queries/* HTTP routes are Phase 4 work
+        // tracked in CEN-1198; the canonical SDK manager lands alongside them.
+        // Today's `client.smartQueries` namespace is the supported way to call
+        // saved queries from the SDK.)
+        // Top-level canonical overload
+        const r4 = yield client.queryRecords('orders', {
+            resource: 'orders',
+            where: { 'data.status': { eq: 'paid' } },
+            page: { limit: 100 },
+        });
+        console.log(r4.data, r4.meta);
+        // Legacy GET-adapter form still type-checks (and emits a one-shot warn at runtime)
+        const r5 = yield client.queryRecords('orders', {
+            'data.status': 'paid',
+            sort: '-createdAt',
+        });
+        console.log(r5.data);
+    });
+}
+void exerciseSdk;