@eidos.space/eidos-file 3.7.0 → 4.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/FIELD-CONVERSION.md +6 -2
- package/dist/{adapter-contract-DLze8O3C.d.mts → adapter-contract-CSbe2Wbp.d.mts} +2 -2
- package/dist/{adapter-contract-DLze8O3C.d.mts.map → adapter-contract-CSbe2Wbp.d.mts.map} +1 -1
- package/dist/better-sqlite3.d.mts +2 -2
- package/dist/better-sqlite3.mjs +1 -1
- package/dist/browser.d.mts +4 -4
- package/dist/browser.d.mts.map +1 -1
- package/dist/browser.mjs +3 -3
- package/dist/browser.mjs.map +1 -1
- package/dist/{csv-NK8Rti5O.mjs → csv-DSZ72Fkf.mjs} +18 -6
- package/dist/csv-DSZ72Fkf.mjs.map +1 -0
- package/dist/csv.d.mts +5 -1
- package/dist/csv.d.mts.map +1 -1
- package/dist/csv.mjs +1 -1
- package/dist/index.d.mts +38 -5
- package/dist/index.d.mts.map +1 -1
- package/dist/index.mjs +400 -44
- package/dist/index.mjs.map +1 -1
- package/dist/node-sqlite.d.mts +9 -4
- package/dist/node-sqlite.d.mts.map +1 -1
- package/dist/node-sqlite.mjs +40 -3
- package/dist/node-sqlite.mjs.map +1 -1
- package/dist/{runtime-WzTMDrCe.d.mts → runtime-CB1g73FF.d.mts} +206 -14
- package/dist/runtime-CB1g73FF.d.mts.map +1 -0
- package/dist/{runtime-CTUCLd5Z.mjs → runtime-CpJ2VAXw.mjs} +1225 -178
- package/dist/runtime-CpJ2VAXw.mjs.map +1 -0
- package/dist/{sqlite-wasm-LbUUazaL.mjs → sqlite-wasm-Can22vNb.mjs} +8 -3
- package/dist/sqlite-wasm-Can22vNb.mjs.map +1 -0
- package/dist/{system-metadata-merge-D1jeYLZa.mjs → system-metadata-merge-BMBzxVo0.mjs} +123 -3
- package/dist/system-metadata-merge-BMBzxVo0.mjs.map +1 -0
- package/dist/{system-metadata-merge-CzWtCvqE.d.mts → system-metadata-merge-BNLOu74_.d.mts} +32 -3
- package/dist/{system-metadata-merge-CzWtCvqE.d.mts.map → system-metadata-merge-BNLOu74_.d.mts.map} +1 -1
- package/dist/{temporal-C-RGZNiQ.d.mts → temporal-DL3k3udh.d.mts} +6 -5
- package/dist/temporal-DL3k3udh.d.mts.map +1 -0
- package/package.json +4 -2
- package/dist/csv-NK8Rti5O.mjs.map +0 -1
- package/dist/runtime-CTUCLd5Z.mjs.map +0 -1
- package/dist/runtime-WzTMDrCe.d.mts.map +0 -1
- package/dist/sqlite-wasm-LbUUazaL.mjs.map +0 -1
- package/dist/system-metadata-merge-D1jeYLZa.mjs.map +0 -1
- package/dist/temporal-C-RGZNiQ.d.mts.map +0 -1
package/dist/index.mjs
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
import { A as isEidosFileUuid, C as assertEidosFileDisplayName, D as createEidosFileIdentifier, E as assertEidosFileUuid, F as EidosFileError, M as canonicalizeEidosFileJson, N as isCanonicalEidosFileJson, O as createEidosFileUuid, P as parseEidosFileJson, S as assertEidosFileColumnName, T as assertEidosFileTableName, _ as encodeEidosFileAttachmentPaths, a as parseEidosFileSelectOptions, b as normalizeEidosFileAttachmentPath, d as normalizeEidosFileDate, f as normalizeEidosFileInstant, g as eidosFileUriClass, h as decodeEidosFileValues, i as parseEidosFileSelectDefaultOption, j as quoteIdentifier, k as isEidosFileReservedTableName, l as isCanonicalEidosFileDate, m as decodeEidosFileAttachmentPaths, n as assertEidosFileSelectDefaultOption, o as currentEidosFileInstant, p as assertEidosFileValues, r as assertEidosFileSelectOptions, t as assertEidosFileMultiSelectHasNoDefaultOption, u as isCanonicalEidosFileInstant, v as encodeEidosFileValues, w as assertEidosFileTableId, x as EidosUuidV7Generator, y as isSafeEidosFileUri } from "./select-options-DSzDn3qm.mjs";
|
|
2
|
-
import { a as eidosFileTypeHandler, c as AdapterTransportRuntimeClient, d as transportFitsHostLimit, f as validateAdapterCarrier, i as EidosFileSession, l as AdapterTransportServer, n as EidosFileHandlerRegistry, o as EidosFileRuntimeDataSource, p as validateAdapterEnvelope, r as EidosFileHostError, s as eidosFileSnapshot, t as SQLiteWasmConnectionPort, u as EIDOS_ADAPTER_TRANSPORT_LIMITS } from "./sqlite-wasm-
|
|
3
|
-
import { $ as
|
|
4
|
-
import { _ as isMutableEidosFileFieldType, a as eidosFileCsvExportHeader, b as decodeEidosFileStringArray, c as importEidosFileCsv, d as prepareEidosFileCsvImport, f as MUTABLE_BASE_FIELD_TYPES, g as encodeEidosFileMultiSelectValues, h as eidosFileFieldDisplayValues, i as createEidosFileCsvRowEncoder, l as parseEidosFileCsvRows, m as eidosFileFieldConversionMayRequireLossyConfirmation, n as EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, o as eidosFileCsvRowToEidosFileRow, p as decodeEidosFileMultiSelectValues, r as createEidosFileCsvImportPlan, s as encodeEidosFileCsvRecord, t as EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, u as planEidosFileCsvImport, v as planEidosFileFieldConversion, x as encodeEidosFileJsonArray, y as decodeEidosFileJsonArray } from "./csv-
|
|
5
|
-
import { n as mergeEidosSystemMetadata, t as EIDOS_SYSTEM_METADATA_TABLES } from "./system-metadata-merge-
|
|
2
|
+
import { a as eidosFileTypeHandler, c as AdapterTransportRuntimeClient, d as transportFitsHostLimit, f as validateAdapterCarrier, i as EidosFileSession, l as AdapterTransportServer, n as EidosFileHandlerRegistry, o as EidosFileRuntimeDataSource, p as validateAdapterEnvelope, r as EidosFileHostError, s as eidosFileSnapshot, t as SQLiteWasmConnectionPort, u as EIDOS_ADAPTER_TRANSPORT_LIMITS } from "./sqlite-wasm-Can22vNb.mjs";
|
|
3
|
+
import { $ as isEidosFileCalendarDayValue, $t as assertInt64Decimal, A as eidosFileRowQuerySearchFields, At as EIDOS_FILE_FORMULA_FIELDS_TABLE, B as isEidosFileCalendarWindowValue, Bt as SQLITE_HEADER, C as MemoryByteSource, Ct as eidosFileTypeRefQueryCapabilities, D as compileEidosFileRowQuery, Dt as EIDOS_FILE_FIELDS_TABLE, E as assertEidosFileRowQuery, Et as EIDOS_FILE_FEATURES_TABLE, F as normalizeEidosFileSorts, Ft as EIDOS_FILE_REQUIRED_TABLES, G as isEidosFileCalendarPeriodValue, Gt as eidosFileConversionTargetNullable, H as eidosFileCalendarPeriodBounds, Ht as eidosFileColumnStatLabel, I as removeEidosFileFilterField, It as EIDOS_FILE_SCHEMA_VERSION, J as EIDOS_FILE_CALENDAR_TIME_ZONE_DATA, Jt as planCanonicalFieldConversion, K as EIDOS_FILE_CALENDAR_MAX_YEAR, Kt as eidosFileTextMultiSelectChoices, L as EIDOS_FILE_CALENDAR_WINDOW_COUNT_MAX, Lt as EIDOS_FILE_SYSTEM_COLUMNS, M as isEidosFileFilterOperator, Mt as EIDOS_FILE_META_TABLE, N as normalizeEidosFileFilter, Nt as EIDOS_FILE_MIME_TYPE, O as eidosFileRowQueryAffectedByFieldChanges, Ot as EIDOS_FILE_FORMAT, P as normalizeEidosFileRowQuery, Pt as EIDOS_FILE_RELATION_FIELDS_TABLE, Q as eidosFileCalendarTimeZones, R as eidosFileCalendarWindowBounds, Rt as EIDOS_FILE_TABLES_TABLE, S as encodeEidosFileRelationIds, St as eidosFileFieldValueType, T as parseNonNegativeInt64, Tt as EIDOS_FILE_EXTENSION, U as hasEidosFileCalendarPeriodQuery, Ut as eidosFileColumnStatTypesForField, V as assertEidosFileCalendarContext, Vt as hasEidosFileSqliteHeader, W as hasEidosFileCalendarQuery, Wt as eidosFileConversionCanReusePhysicalColumn, X as eidosFileCalendarDateRangeIntervals, Xt as ConnectionPortEidosFileConnection, Y as assertEidosFileCalendarZone, Yt as recommendedEidosFileConversionPolicies, Z as eidosFileCalendarDayBounds, Zt as EidosAdapterError, _ as assertEidosFileTemporalDefault, _t as compileEidosFileFormulaSource, a as EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT_MAX_BYTES, at as eidosFileLookupDisplayType, b as decodeEidosFileRelationDisplay, bt as configuredTypeRef, c as upgradeEidosFileDateQuery, ct as eidosFileLookupTargetDisplayType, d as EIDOS_FILE_SCHEMA_SQL, dt as EIDOS_FILE_FORMULA_FIELD_FUNCTION_NAMES, en as assertUnicodeString, et as projectEidosFileCalendarInstant, f as configureEidosFileConnection, ft as EIDOS_FILE_FORMULA_FUNCTION_NAMES, g as assertEidosFileCreationContext, gt as compileEidosFileFormulaFields, h as setEidosFileMetadata, ht as compileEidosFileFormula, i as EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT, it as eidosFileLookupAggregateSupportsTarget, j as eidosFileSortExpression, jt as EIDOS_FILE_LOOKUP_FIELDS_TABLE, k as eidosFileRowQueryPredicateColumns, kt as EIDOS_FILE_FORMAT_VERSION, l as scanStableRowPages, lt as eidosFileLookupTargetValueType, m as initializeEidosFileSchema, mt as assertEidosFileFormulaProfile, n as validateEidosFile, nn as nativeToSqlValue, nt as supportsEidosFileCalendarProfile, o as eidosFileDateQueryUpgradeReceipt, ot as eidosFileLookupElementType, p as incrementEidosFileRevision, pt as EIDOS_FILE_FORMULA_PROFILE, q as EIDOS_FILE_CALENDAR_MIN_YEAR, qt as isEidosFileUriReference, r as smallestDependencyCycle, rn as sqlValueToNative, rt as eidosFileFieldStoresJsonArray, s as hasRetiredEidosFileDateQuery, st as eidosFileLookupStorageCodec, t as EidosFileRuntime, tt as resolveEidosFileCalendarInstant, u as EIDOS_FILE_FORMAT_VERSION_TEXT, ut as eidosFileLookupValueType, v as eidosFileTemporalDefaultValue, vt as eidosFileFormulaReferences, w as cancellationPortFromSignal, wt as EIDOS_FILE_APPLICATION_ID, x as decodeEidosFileRelationIds, xt as eidosFileFieldQueryCapabilities, y as enableTemporalDefaultsFeature, yt as rewriteEidosFileFormulaFieldReferences, z as hasEidosFileCalendarWindowQuery, zt as EIDOS_FILE_VIEWS_TABLE } from "./runtime-CpJ2VAXw.mjs";
|
|
4
|
+
import { _ as isMutableEidosFileFieldType, a as eidosFileCsvExportHeader, b as decodeEidosFileStringArray, c as importEidosFileCsv, d as prepareEidosFileCsvImport, f as MUTABLE_BASE_FIELD_TYPES, g as encodeEidosFileMultiSelectValues, h as eidosFileFieldDisplayValues, i as createEidosFileCsvRowEncoder, l as parseEidosFileCsvRows, m as eidosFileFieldConversionMayRequireLossyConfirmation, n as EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, o as eidosFileCsvRowToEidosFileRow, p as decodeEidosFileMultiSelectValues, r as createEidosFileCsvImportPlan, s as encodeEidosFileCsvRecord, t as EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, u as planEidosFileCsvImport, v as planEidosFileFieldConversion, x as encodeEidosFileJsonArray, y as decodeEidosFileJsonArray } from "./csv-DSZ72Fkf.mjs";
|
|
5
|
+
import { i as planEidosSchemaMerge, n as mergeEidosSystemMetadata, r as normalizeEidosSchemaMerge, t as EIDOS_SYSTEM_METADATA_TABLES } from "./system-metadata-merge-BMBzxVo0.mjs";
|
|
6
6
|
//#region src/form-view.ts
|
|
7
7
|
const EIDOS_FILE_FORM_VIEW_TYPE = "form";
|
|
8
8
|
const EIDOS_FILE_FORM_INPUT_FIELD_TYPES = [
|
|
@@ -107,6 +107,12 @@ function mergeEidosFilePluginConfig(settings, pluginId, value, expectedVersion)
|
|
|
107
107
|
};
|
|
108
108
|
}
|
|
109
109
|
//#endregion
|
|
110
|
+
//#region src/cli-host-initialization.ts
|
|
111
|
+
const initializers = /* @__PURE__ */ new WeakMap();
|
|
112
|
+
function registerCliTableInitializer(service, initialize) {
|
|
113
|
+
initializers.set(service, initialize);
|
|
114
|
+
}
|
|
115
|
+
//#endregion
|
|
110
116
|
//#region src/runtime-service.ts
|
|
111
117
|
const EIDOS_RUNTIME_LIMITS = Object.freeze({
|
|
112
118
|
requestBytesMax: 8 * 1024 * 1024,
|
|
@@ -140,8 +146,14 @@ const EIDOS_RUNTIME_LIMITS = Object.freeze({
|
|
|
140
146
|
undoBytesMax: 1
|
|
141
147
|
});
|
|
142
148
|
const READONLY_CAPABILITIES = Object.freeze({
|
|
149
|
+
viewCreationDefaultsVersion: 1,
|
|
150
|
+
calendarWindowVersion: 1,
|
|
151
|
+
temporalDefaultsVersion: 1,
|
|
152
|
+
calendarQueryVersion: 2,
|
|
153
|
+
calendarPeriodTimeZoneData: [EIDOS_FILE_CALENDAR_TIME_ZONE_DATA],
|
|
143
154
|
readRows: true,
|
|
144
155
|
batchRowPages: true,
|
|
156
|
+
rowIndex: true,
|
|
145
157
|
schemaPaging: true,
|
|
146
158
|
cursorPaging: true,
|
|
147
159
|
aggregate: true,
|
|
@@ -224,6 +236,9 @@ var EidosRuntimeService = class {
|
|
|
224
236
|
requestControls = /* @__PURE__ */ new Map();
|
|
225
237
|
schemaPlans = /* @__PURE__ */ new Map();
|
|
226
238
|
schemaPlanSequence = 0;
|
|
239
|
+
requestInstant;
|
|
240
|
+
requestCalendar;
|
|
241
|
+
requestedReference;
|
|
227
242
|
queue = Promise.resolve();
|
|
228
243
|
state = "open";
|
|
229
244
|
constructor(connection, core, environment, writable, generator) {
|
|
@@ -233,11 +248,20 @@ var EidosRuntimeService = class {
|
|
|
233
248
|
this.writable = writable;
|
|
234
249
|
this.generator = generator;
|
|
235
250
|
this.capabilitiesValue = runtimeCapabilities(writable);
|
|
251
|
+
registerCliTableInitializer(this, (change, context) => this.initializeCliTable(change, context));
|
|
236
252
|
if (writable) this.importCsv = (request, context) => this.importCsvRequest(request, context);
|
|
237
253
|
this.epoch = generator.next();
|
|
238
254
|
this.cursorSecret = environment.entropy.randomBytes(16).slice();
|
|
239
255
|
if (this.cursorSecret.byteLength !== 16) throw runtimeError("adapter-error", "EntropyPort returned an invalid cursor authentication key");
|
|
240
256
|
this.hostBridge = {
|
|
257
|
+
queuedRead: (operation, context) => this.invoke(context, () => {
|
|
258
|
+
if (Object.prototype.toString.call(operation) === "[object AsyncFunction]") throw runtimeError("invalid-request", "Host read callbacks must complete synchronously");
|
|
259
|
+
return this.read(() => {
|
|
260
|
+
const value = operation();
|
|
261
|
+
if (value !== null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw runtimeError("invalid-request", "Host read callbacks must not return thenables");
|
|
262
|
+
return value;
|
|
263
|
+
});
|
|
264
|
+
}, false, void 0, false, false, true),
|
|
241
265
|
allocateFileEntry: (request, context) => this.invoke(context, () => this.allocateFileEntry(request), false, request),
|
|
242
266
|
createPublicationSnapshot: (request, context) => this.invoke(context, async () => {
|
|
243
267
|
if (parseRevision(request.maxBytes, "maxBytes") < 0n) throw runtimeError("invalid-request", "maxBytes must be non-negative");
|
|
@@ -299,16 +323,18 @@ var EidosRuntimeService = class {
|
|
|
299
323
|
}
|
|
300
324
|
getSchemaPage(request, context) {
|
|
301
325
|
return this.invoke(context, async () => this.read(async () => {
|
|
326
|
+
if (request.calendarWindowVersion !== void 0 && (request.calendarWindowVersion !== 1 || request.calendarQueryVersion !== 2)) throw runtimeError("unsupported", "Unsupported client calendar window version");
|
|
327
|
+
if (request.calendarQueryVersion !== void 0 && request.calendarQueryVersion !== 2) throw runtimeError("unsupported", "Unsupported client calendar query version");
|
|
302
328
|
assertLimit(request.limit, EIDOS_RUNTIME_LIMITS.schemaPageSizeMax, "limit");
|
|
303
329
|
const snapshot = this.snapshot();
|
|
304
330
|
assertCurrentRevision(request.revision, snapshot.revision);
|
|
305
331
|
let offset = 0;
|
|
306
332
|
if (request.cursor !== void 0) {
|
|
307
333
|
const payload = this.decodeCursor(request.cursor, "schema");
|
|
308
|
-
if (payload.fileId !== snapshot.fileId || payload.revision !== request.revision || typeof payload.offset !== "number" || !Number.isSafeInteger(payload.offset) || payload.offset < 0) throw runtimeError("invalid-query", "Invalid schema cursor");
|
|
334
|
+
if (payload.fileId !== snapshot.fileId || payload.revision !== request.revision || payload.calendarQueryVersion !== (request.calendarQueryVersion ?? null) || payload.calendarWindowVersion !== (request.calendarWindowVersion ?? null) || typeof payload.offset !== "number" || !Number.isSafeInteger(payload.offset) || payload.offset < 0) throw runtimeError("invalid-query", "Invalid schema cursor");
|
|
309
335
|
offset = payload.offset;
|
|
310
336
|
}
|
|
311
|
-
const objects = this.schemaDescriptors();
|
|
337
|
+
const objects = this.schemaDescriptors(request.calendarQueryVersion, request.calendarWindowVersion);
|
|
312
338
|
const page = objects.slice(offset, offset + request.limit);
|
|
313
339
|
if (offset > objects.length) throw runtimeError("invalid-query", "Schema cursor is past the end");
|
|
314
340
|
const responseFor = (prefix) => {
|
|
@@ -320,6 +346,8 @@ var EidosRuntimeService = class {
|
|
|
320
346
|
nextCursor: nextOffset < objects.length ? this.encodeCursor("schema", {
|
|
321
347
|
fileId: snapshot.fileId,
|
|
322
348
|
revision: snapshot.revision,
|
|
349
|
+
calendarQueryVersion: request.calendarQueryVersion ?? null,
|
|
350
|
+
calendarWindowVersion: request.calendarWindowVersion ?? null,
|
|
323
351
|
offset: nextOffset
|
|
324
352
|
}) : null
|
|
325
353
|
};
|
|
@@ -342,7 +370,10 @@ var EidosRuntimeService = class {
|
|
|
342
370
|
const direction = request.direction ?? "forward";
|
|
343
371
|
const metadata = this.core.info();
|
|
344
372
|
const projectionDigest = await projectionHash(request.projection);
|
|
345
|
-
const queryDigest = await hashJson(
|
|
373
|
+
const queryDigest = await hashJson({
|
|
374
|
+
query: normalizedRuntimeQuery(request.query),
|
|
375
|
+
calendar: this.requestCalendar ?? null
|
|
376
|
+
});
|
|
346
377
|
const backwardQuery = reverseRuntimeQuery(request.query, this.core.listFields(request.tableId));
|
|
347
378
|
const traversalQuery = direction === "forward" ? request.query : backwardQuery;
|
|
348
379
|
const traversal = this.compatibilityQuery(request.tableId, traversalQuery);
|
|
@@ -354,10 +385,11 @@ var EidosRuntimeService = class {
|
|
|
354
385
|
const selected = direction === "forward" ? cursor.forward : cursor.backward;
|
|
355
386
|
if (typeof selected !== "string") throw runtimeError("invalid-query", "Row cursor boundary is invalid");
|
|
356
387
|
coreCursor = selected;
|
|
388
|
+
if (typeof cursor.referenceInstant === "string") this.bindCursorReference(cursor.referenceInstant);
|
|
357
389
|
}
|
|
358
390
|
const extraFields = (request.query.sort ?? []).map((sort) => sort.fieldId);
|
|
359
391
|
const fields = Array.from(new Set([...request.projection.fields, ...extraFields]));
|
|
360
|
-
const
|
|
392
|
+
const resultRows = this.core.runtimeQueryRows(request.tableId, {
|
|
361
393
|
fields,
|
|
362
394
|
query: traversal,
|
|
363
395
|
limit: request.limit + 1,
|
|
@@ -365,8 +397,8 @@ var EidosRuntimeService = class {
|
|
|
365
397
|
cursor: coreCursor,
|
|
366
398
|
resolveRelations: request.projection.resolveRelations.length > 0
|
|
367
399
|
});
|
|
368
|
-
const hasMoreInTraversal =
|
|
369
|
-
const traversalRows =
|
|
400
|
+
const hasMoreInTraversal = resultRows.length > request.limit;
|
|
401
|
+
const traversalRows = resultRows.slice(0, request.limit);
|
|
370
402
|
const logicalRows = direction === "forward" ? traversalRows : traversalRows.reverse();
|
|
371
403
|
const columns = this.columns(request.tableId, request.projection);
|
|
372
404
|
const rows = this.projectRows(request.tableId, request.projection, logicalRows, columns);
|
|
@@ -377,6 +409,7 @@ var EidosRuntimeService = class {
|
|
|
377
409
|
tableId: request.tableId,
|
|
378
410
|
revision: String(metadata.revision),
|
|
379
411
|
queryHash: queryDigest,
|
|
412
|
+
referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
|
|
380
413
|
projectionHash: projectionDigest,
|
|
381
414
|
forward: this.core.createRowCursor(request.tableId, query, row),
|
|
382
415
|
backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardQuery), row)
|
|
@@ -391,10 +424,14 @@ var EidosRuntimeService = class {
|
|
|
391
424
|
projectionHash: projectionDigest,
|
|
392
425
|
columns,
|
|
393
426
|
rows,
|
|
427
|
+
...usesClockFilter(request.query.filter) ? {
|
|
428
|
+
total: String(this.core.countRows(request.tableId, query)),
|
|
429
|
+
referenceInstant: this.requestInstant
|
|
430
|
+
} : {},
|
|
394
431
|
nextCursor: hasLater ? boundaryCursor(logicalRows.at(-1)) : null,
|
|
395
432
|
previousCursor: hasEarlier ? boundaryCursor(logicalRows[0]) : null
|
|
396
433
|
};
|
|
397
|
-
}), false, request);
|
|
434
|
+
}), false, request, true, true);
|
|
398
435
|
}
|
|
399
436
|
queryRowPages(request, context) {
|
|
400
437
|
return this.invoke(context, async () => this.read(async () => {
|
|
@@ -414,7 +451,11 @@ var EidosRuntimeService = class {
|
|
|
414
451
|
fileId: metadata.fileId,
|
|
415
452
|
tableId: request.tableId,
|
|
416
453
|
revision: String(metadata.revision),
|
|
417
|
-
queryHash: await hashJson(
|
|
454
|
+
queryHash: await hashJson({
|
|
455
|
+
query: normalizedRuntimeQuery(query),
|
|
456
|
+
calendar: this.requestCalendar ?? null
|
|
457
|
+
}),
|
|
458
|
+
referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
|
|
418
459
|
projectionHash: projectionDigest,
|
|
419
460
|
forward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, query), last),
|
|
420
461
|
backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardQuery), last)
|
|
@@ -427,14 +468,18 @@ var EidosRuntimeService = class {
|
|
|
427
468
|
columns,
|
|
428
469
|
rows: this.projectRows(request.tableId, request.projection, page.rows, columns),
|
|
429
470
|
total: String(page.total),
|
|
471
|
+
...usesClockFilter(query.filter) ? { referenceInstant: this.requestInstant } : {},
|
|
430
472
|
nextCursor,
|
|
431
473
|
previousCursor: null
|
|
432
474
|
};
|
|
433
475
|
}));
|
|
434
|
-
}), false, request);
|
|
476
|
+
}), false, request, true, true);
|
|
477
|
+
}
|
|
478
|
+
getRowIndex(request, context) {
|
|
479
|
+
return this.invoke(context, async () => this.read(async () => this.core.getRowIndexValue(request.tableId, request.rowId, this.compatibilityQuery(request.tableId, request.query))), false, request, true, true);
|
|
435
480
|
}
|
|
436
481
|
getRecordNeighbors(request, context) {
|
|
437
|
-
return this.invoke(context, async () => this.read(async () => this.core.getRecordNeighbors(request.tableId, request.rowId, this.compatibilityQuery(request.tableId, request.query))), false, request);
|
|
482
|
+
return this.invoke(context, async () => this.read(async () => this.core.getRecordNeighbors(request.tableId, request.rowId, this.compatibilityQuery(request.tableId, request.query))), false, request, true, true);
|
|
438
483
|
}
|
|
439
484
|
getRowsById(request, context) {
|
|
440
485
|
return this.invoke(context, async () => this.read(async () => {
|
|
@@ -451,20 +496,22 @@ var EidosRuntimeService = class {
|
|
|
451
496
|
}), false, request);
|
|
452
497
|
}
|
|
453
498
|
aggregate(request, context) {
|
|
454
|
-
return this.invoke(context, () => this.read(() => this.aggregateNow(request)), false, request);
|
|
499
|
+
return this.invoke(context, () => this.read(() => this.aggregateNow(request)), false, request, true, true);
|
|
455
500
|
}
|
|
456
501
|
aggregateTable(tableId, options, query = {}) {
|
|
457
502
|
return this.read(() => this.core.aggregateTable(tableId, options, query));
|
|
458
503
|
}
|
|
459
504
|
groupRows(request, context) {
|
|
460
|
-
return this.invoke(context, async () => this.read(async () => this.groupRowsNow(request)), false, request);
|
|
505
|
+
return this.invoke(context, async () => this.read(async () => this.groupRowsNow(request)), false, request, true, true);
|
|
461
506
|
}
|
|
462
507
|
queryGroupRows(request, context) {
|
|
463
508
|
return this.invoke(context, async () => this.read(async () => {
|
|
464
509
|
assertLimit(request.limit, EIDOS_RUNTIME_LIMITS.pageSizeMax, "limit");
|
|
465
510
|
const cursor = this.decodeCursor(request.cursor, "group-rows");
|
|
511
|
+
if (typeof cursor.referenceInstant === "string") this.bindCursorReference(cursor.referenceInstant);
|
|
466
512
|
const source = cursor.request;
|
|
467
513
|
if (!source || typeof source !== "object" || Array.isArray(source)) throw runtimeError("invalid-query", "Invalid group row cursor");
|
|
514
|
+
if (canonicalizeEidosFileJson(request.calendar ?? null) !== canonicalizeEidosFileJson(source.calendar ?? null)) throw runtimeError("invalid-query", "Group cursor calendar context mismatch");
|
|
468
515
|
assertProjection(source.projection);
|
|
469
516
|
const metadata = this.core.info();
|
|
470
517
|
const projectionDigest = await projectionHash(source.projection);
|
|
@@ -497,6 +544,7 @@ var EidosRuntimeService = class {
|
|
|
497
544
|
revision: String(metadata.revision),
|
|
498
545
|
projectionHash: projectionDigest,
|
|
499
546
|
bindingHash: bindingDigest,
|
|
547
|
+
referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
|
|
500
548
|
request: groupCursorSource(source),
|
|
501
549
|
groupKey,
|
|
502
550
|
forward: this.core.createRowCursor(source.tableId, this.compatibilityQuery(source.tableId, groupQuery), row),
|
|
@@ -512,11 +560,12 @@ var EidosRuntimeService = class {
|
|
|
512
560
|
projectionHash: projectionDigest,
|
|
513
561
|
columns,
|
|
514
562
|
groupKey,
|
|
563
|
+
...usesClockFilter(source.query.filter) ? { referenceInstant: this.requestInstant } : {},
|
|
515
564
|
rows: this.projectRows(source.tableId, source.projection, logicalRows, columns),
|
|
516
565
|
nextCursor: hasLater ? rowCursor(logicalRows.at(-1)) : null,
|
|
517
566
|
previousCursor: hasEarlier ? rowCursor(logicalRows[0]) : null
|
|
518
567
|
};
|
|
519
|
-
}), false, request);
|
|
568
|
+
}), false, request, true, true);
|
|
520
569
|
}
|
|
521
570
|
previewFormula(request, context) {
|
|
522
571
|
return this.invoke(context, () => {
|
|
@@ -584,6 +633,12 @@ var EidosRuntimeService = class {
|
|
|
584
633
|
mutateRowsRequest(request, context, reversibleDeletes) {
|
|
585
634
|
return this.invoke(context, async () => {
|
|
586
635
|
this.assertWritable("mutateRows");
|
|
636
|
+
if (request.calendar !== void 0) {
|
|
637
|
+
assertEidosFileCalendarContext(request.calendar);
|
|
638
|
+
this.requestCalendar = request.calendar;
|
|
639
|
+
}
|
|
640
|
+
if (request.creationQuery !== void 0 && (!request.creationQuery || typeof request.creationQuery !== "object" || Array.isArray(request.creationQuery) || Object.keys(request.creationQuery).some((key) => key !== "filter"))) throw runtimeError("invalid-query", "Creation query accepts only a filter");
|
|
641
|
+
if (request.creationContext !== void 0) assertEidosFileCreationContext(request.creationContext);
|
|
587
642
|
if (request.changes.length < 1 || request.changes.length > EIDOS_RUNTIME_LIMITS.mutationRowsMax) throw runtimeError("invalid-request", "changes must be within mutationRowsMax");
|
|
588
643
|
if (request.changes.reduce((total, change) => total + ("values" in change ? Object.keys(change.values).length : 0), 0) > EIDOS_RUNTIME_LIMITS.mutationCellsMax) throw runtimeError("resource-limit", "Mutation exceeds mutationCellsMax");
|
|
589
644
|
assertJcsBytes(request, EIDOS_RUNTIME_LIMITS.mutationBytesMax, "Row mutation");
|
|
@@ -622,7 +677,7 @@ var EidosRuntimeService = class {
|
|
|
622
677
|
rowId
|
|
623
678
|
});
|
|
624
679
|
}
|
|
625
|
-
const inserts = request.changes.filter((change) => change.kind === "create").map((change) => ({ fields: this.mutationValues(request.tableId, change.values,
|
|
680
|
+
const inserts = request.changes.filter((change) => change.kind === "create").map((change) => ({ fields: this.mutationValues(request.tableId, change.values, request.creationQuery?.filter === void 0, request.creationContext) }));
|
|
626
681
|
const updates = request.changes.filter((change) => change.kind === "update").map((change) => ({
|
|
627
682
|
id: change.rowId,
|
|
628
683
|
fields: this.mutationValues(request.tableId, change.values)
|
|
@@ -636,6 +691,8 @@ var EidosRuntimeService = class {
|
|
|
636
691
|
rows: []
|
|
637
692
|
} : this.core.mutateRows({
|
|
638
693
|
tableId: request.tableId,
|
|
694
|
+
...request.creationQuery ? { creationQuery: this.compatibilityQuery(request.tableId, request.creationQuery) } : {},
|
|
695
|
+
creationContext: request.creationContext,
|
|
639
696
|
insert: inserts,
|
|
640
697
|
update: updates,
|
|
641
698
|
delete: deletes,
|
|
@@ -710,7 +767,7 @@ var EidosRuntimeService = class {
|
|
|
710
767
|
}));
|
|
711
768
|
}, false, request);
|
|
712
769
|
}
|
|
713
|
-
mutationValues(tableId, values, completeCreate = false) {
|
|
770
|
+
mutationValues(tableId, values, completeCreate = false, creationContext) {
|
|
714
771
|
const tableFields = this.core.listFields(tableId);
|
|
715
772
|
const fields = new Map(tableFields.map((field) => [field.id, field]));
|
|
716
773
|
const normalized = {};
|
|
@@ -738,6 +795,17 @@ var EidosRuntimeService = class {
|
|
|
738
795
|
if (completeCreate) for (const field of tableFields) {
|
|
739
796
|
const fieldId = field.id;
|
|
740
797
|
if (!fieldWritable(field) || fieldId in normalized) continue;
|
|
798
|
+
if (field.type === "date" || field.type === "datetime") {
|
|
799
|
+
const value = eidosFileTemporalDefaultValue(field.type, field.settings, this.requestInstant ?? checkedNowInstant(this.environment), creationContext);
|
|
800
|
+
if (value !== null) {
|
|
801
|
+
normalized[fieldId] = value;
|
|
802
|
+
continue;
|
|
803
|
+
}
|
|
804
|
+
}
|
|
805
|
+
if (field.type === "checkbox") {
|
|
806
|
+
normalized[fieldId] = false;
|
|
807
|
+
continue;
|
|
808
|
+
}
|
|
741
809
|
if (field.type === "select") {
|
|
742
810
|
const defaultOption = parseEidosFileSelectDefaultOption(field.settings);
|
|
743
811
|
if (defaultOption !== null) {
|
|
@@ -869,6 +937,8 @@ var EidosRuntimeService = class {
|
|
|
869
937
|
async mutateView(request, context) {
|
|
870
938
|
return this.invoke(context, () => {
|
|
871
939
|
this.assertWritable("mutateView");
|
|
940
|
+
if (request.calendarWindowVersion !== void 0 && (request.calendarWindowVersion !== 1 || request.calendarQueryVersion !== 2)) throw runtimeError("invalid-request", "Unsupported calendar window consumer version");
|
|
941
|
+
if (request.calendarQueryVersion !== void 0 && request.calendarQueryVersion !== 2) throw runtimeError("invalid-request", "Unsupported calendar query consumer version");
|
|
872
942
|
if (request.changes.length < 1) throw runtimeError("invalid-request", "View mutation changes are required");
|
|
873
943
|
const before = this.core.info();
|
|
874
944
|
assertCurrentRevision(request.expectedRevision, String(before.revision));
|
|
@@ -887,6 +957,7 @@ var EidosRuntimeService = class {
|
|
|
887
957
|
this.core.applyCanonicalMutation(() => {
|
|
888
958
|
for (const change of request.changes) {
|
|
889
959
|
if (change.kind === "create-view") {
|
|
960
|
+
assertRuntimeSavedViewQuery(this.core.listFields(change.tableId), change.query);
|
|
890
961
|
const view = this.core.createView(change.tableId, {
|
|
891
962
|
name: assertEidosFileDisplayName(change.name, "View name"),
|
|
892
963
|
type: change.type,
|
|
@@ -906,12 +977,33 @@ var EidosRuntimeService = class {
|
|
|
906
977
|
affected.add(view.id);
|
|
907
978
|
continue;
|
|
908
979
|
}
|
|
909
|
-
|
|
980
|
+
const current = this.allViews().find((view) => view.id === change.viewId);
|
|
981
|
+
if (!current) throw runtimeError("not-found", "View not found");
|
|
910
982
|
if (change.kind === "delete-view") {
|
|
911
983
|
this.core.deleteView(change.viewId);
|
|
912
984
|
affected.add(change.viewId);
|
|
913
985
|
continue;
|
|
914
986
|
}
|
|
987
|
+
if (change.kind === "upgrade-date-query" || change.kind === "restore-date-query") {
|
|
988
|
+
if (change.kind === "upgrade-date-query") {
|
|
989
|
+
const preview = upgradeEidosFileDateQuery(JSON.parse(current.query));
|
|
990
|
+
assertRuntimeSavedViewQuery(this.core.listFields(current.tableId), preview.query);
|
|
991
|
+
} else {
|
|
992
|
+
const receipt = current.properties?.[EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT];
|
|
993
|
+
if (!receipt || typeof receipt !== "object" || Array.isArray(receipt) || !("originalQuery" in receipt)) throw runtimeError("invalid-value", "No date query recovery receipt is available");
|
|
994
|
+
const preview = upgradeEidosFileDateQuery(receipt.originalQuery);
|
|
995
|
+
assertRuntimeSavedViewQuery(this.core.listFields(current.tableId), preview.query);
|
|
996
|
+
}
|
|
997
|
+
this.core.updateView(change.viewId, change.kind === "upgrade-date-query" ? { upgradeDateQuery: true } : { restoreDateQuery: true });
|
|
998
|
+
affected.add(change.viewId);
|
|
999
|
+
continue;
|
|
1000
|
+
}
|
|
1001
|
+
if (current.queryStatus === "unsupported" && change.patch.query !== void 0) throw runtimeError("unsupported", "Unsupported View query must be upgraded explicitly before editing");
|
|
1002
|
+
if (change.patch.query !== void 0 && hasEidosFileCalendarPeriodQuery(JSON.parse(current.query)) && request.calendarQueryVersion !== 2) throw runtimeError("unsupported", "This View requires a client that explicitly accepts calendar query version 2");
|
|
1003
|
+
if (change.patch.query !== void 0) {
|
|
1004
|
+
if (hasEidosFileCalendarWindowQuery(JSON.parse(current.query)) && request.calendarWindowVersion !== 1) throw runtimeError("unsupported", "This View requires a client that explicitly accepts calendar window version 1");
|
|
1005
|
+
}
|
|
1006
|
+
if (change.patch.query !== void 0) assertRuntimeSavedViewQuery(this.core.listFields(current.tableId), change.patch.query);
|
|
915
1007
|
const layout = change.patch.layout === void 0 ? void 0 : objectValue(change.patch.layout);
|
|
916
1008
|
const fieldOrder = Array.isArray(layout?.fieldOrder) ? layout.fieldOrder.filter((fieldId) => typeof fieldId === "string") : null;
|
|
917
1009
|
const hiddenFields = Array.isArray(layout?.hiddenFields) ? layout.hiddenFields.filter((fieldId) => typeof fieldId === "string") : [];
|
|
@@ -1044,6 +1136,38 @@ var EidosRuntimeService = class {
|
|
|
1044
1136
|
return responseFor(dependencies);
|
|
1045
1137
|
}, false, request);
|
|
1046
1138
|
}
|
|
1139
|
+
initializeCliTable(change, context) {
|
|
1140
|
+
return this.invoke(context, () => {
|
|
1141
|
+
this.assertWritable("initializeCliTable");
|
|
1142
|
+
const createdObjects = [];
|
|
1143
|
+
let tableId = "";
|
|
1144
|
+
let viewId = "";
|
|
1145
|
+
this.core.applyCanonicalMutation(() => {
|
|
1146
|
+
const before = this.core.info();
|
|
1147
|
+
if (change.kind !== "create-table" || String(before.revision) !== "0" || before.defaultTableId != null || this.core.listTables().length !== 0 || this.core.connection.query("SELECT id FROM eidos__views").length !== 0) throw runtimeError("invalid-request", "Initial Table requires a fresh File at revision 0");
|
|
1148
|
+
if (this.analyzeSchemaChange(change).classification === "forbidden") throw runtimeError("forbidden", "Initial Table schema is forbidden");
|
|
1149
|
+
this.applySchemaChange(change, createdObjects, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
|
|
1150
|
+
tableId = createdObjects.find((object) => object.object === "table").id;
|
|
1151
|
+
this.applySchemaChange({
|
|
1152
|
+
kind: "set-default-table",
|
|
1153
|
+
tableId
|
|
1154
|
+
}, [], /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
|
|
1155
|
+
viewId = this.core.createView(tableId, {
|
|
1156
|
+
name: "Grid",
|
|
1157
|
+
type: "grid"
|
|
1158
|
+
}).id;
|
|
1159
|
+
}, 0n);
|
|
1160
|
+
return {
|
|
1161
|
+
schema: {
|
|
1162
|
+
revision: String(this.core.info().revision),
|
|
1163
|
+
changed: true,
|
|
1164
|
+
createdObjects: createdObjects.filter((object) => "clientKey" in object)
|
|
1165
|
+
},
|
|
1166
|
+
tableId,
|
|
1167
|
+
viewId
|
|
1168
|
+
};
|
|
1169
|
+
}, false, change);
|
|
1170
|
+
}
|
|
1047
1171
|
async mutateSchema(request, context) {
|
|
1048
1172
|
return this.invoke(context, () => {
|
|
1049
1173
|
this.assertWritable("mutateSchema");
|
|
@@ -1143,11 +1267,11 @@ var EidosRuntimeService = class {
|
|
|
1143
1267
|
tables: String(tables.length),
|
|
1144
1268
|
fields: String(fields.length),
|
|
1145
1269
|
views: String(views.length),
|
|
1146
|
-
features: "
|
|
1270
|
+
features: String(this.core.connection.query("SELECT name FROM eidos__features").length)
|
|
1147
1271
|
}
|
|
1148
1272
|
};
|
|
1149
1273
|
}
|
|
1150
|
-
schemaDescriptors() {
|
|
1274
|
+
schemaDescriptors(calendarQueryVersion, calendarWindowVersion) {
|
|
1151
1275
|
const tables = this.core.listTables();
|
|
1152
1276
|
const tableSettings = new Map(this.core.connection.query("SELECT id, settings_json FROM eidos__tables").map((row) => [row.id, objectValue(JSON.parse(row.settings_json))]));
|
|
1153
1277
|
const tableDescriptors = tables.map((table) => {
|
|
@@ -1162,26 +1286,41 @@ var EidosRuntimeService = class {
|
|
|
1162
1286
|
settings: tableSettings.get(table.id) ?? {}
|
|
1163
1287
|
};
|
|
1164
1288
|
});
|
|
1165
|
-
const fieldDescriptors = tables.flatMap((table) => this.core.listFields(table.id).map((field) =>
|
|
1289
|
+
const fieldDescriptors = tables.flatMap((table) => this.core.listFields(table.id).map((field) => ({
|
|
1290
|
+
...fieldDescriptor(field),
|
|
1291
|
+
writable: this.writable && fieldWritable(field)
|
|
1292
|
+
})));
|
|
1166
1293
|
const views = tables.flatMap((table) => this.core.listViews(table.id).map((view) => ({
|
|
1167
1294
|
object: "view",
|
|
1168
1295
|
id: view.id,
|
|
1169
1296
|
tableId: view.tableId,
|
|
1170
1297
|
name: view.name,
|
|
1171
1298
|
type: view.type,
|
|
1172
|
-
queryStatus
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
...
|
|
1179
|
-
|
|
1299
|
+
...view.queryStatus === "unsupported" || calendarWindowVersion !== 1 && hasEidosFileCalendarWindowQuery(JSON.parse(view.query)) || calendarQueryVersion !== 2 && hasEidosFileCalendarPeriodQuery(JSON.parse(view.query)) ? {
|
|
1300
|
+
queryStatus: "unsupported",
|
|
1301
|
+
query: objectValue(parseEidosFileJson(view.query))
|
|
1302
|
+
} : {
|
|
1303
|
+
queryStatus: "supported",
|
|
1304
|
+
query: isPublicSavedQueryDocument(JSON.parse(view.query)) ? JSON.parse(view.query) : {
|
|
1305
|
+
...view.filter ? { filter: compatibilityFilterToRuntime(view.filter, this.core.listFields(view.tableId)) } : {},
|
|
1306
|
+
...view.sorts.length > 0 ? { sort: view.sorts.map((sort) => ({
|
|
1307
|
+
fieldId: sort.field,
|
|
1308
|
+
direction: sort.direction,
|
|
1309
|
+
...sort.nulls ? { nulls: sort.nulls } : {}
|
|
1310
|
+
})) } : {}
|
|
1311
|
+
}
|
|
1180
1312
|
},
|
|
1181
1313
|
layout: objectValue(view.properties ?? {}),
|
|
1182
1314
|
position: String(view.position ?? 0)
|
|
1183
1315
|
})));
|
|
1184
1316
|
return [
|
|
1317
|
+
...this.core.connection.query("SELECT name, version, required, config_json FROM eidos__features ORDER BY name").map((row) => ({
|
|
1318
|
+
object: "feature",
|
|
1319
|
+
name: row.name,
|
|
1320
|
+
version: row.version,
|
|
1321
|
+
required: row.required === 1,
|
|
1322
|
+
config: objectValue(JSON.parse(row.config_json))
|
|
1323
|
+
})),
|
|
1185
1324
|
...tableDescriptors,
|
|
1186
1325
|
...fieldDescriptors,
|
|
1187
1326
|
...views
|
|
@@ -1201,7 +1340,7 @@ var EidosRuntimeService = class {
|
|
|
1201
1340
|
name: field.name,
|
|
1202
1341
|
valueType: eidosFileFieldValueType(field),
|
|
1203
1342
|
source: field.type === "formula" ? "formula" : field.type === "lookup" ? "lookup" : field.type === "relation" && relation?.direction === "inverse" ? "inverse-relation" : "stored",
|
|
1204
|
-
writable: fieldWritable(field)
|
|
1343
|
+
writable: this.writable && fieldWritable(field)
|
|
1205
1344
|
};
|
|
1206
1345
|
});
|
|
1207
1346
|
}
|
|
@@ -1261,7 +1400,8 @@ var EidosRuntimeService = class {
|
|
|
1261
1400
|
results: request.items.map((item) => ({
|
|
1262
1401
|
key: item.key,
|
|
1263
1402
|
value: count
|
|
1264
|
-
}))
|
|
1403
|
+
})),
|
|
1404
|
+
...usesClockFilter(request.query?.filter) ? { referenceInstant: this.requestInstant } : {}
|
|
1265
1405
|
};
|
|
1266
1406
|
}
|
|
1267
1407
|
const fields = this.core.listFields(request.tableId);
|
|
@@ -1319,14 +1459,29 @@ var EidosRuntimeService = class {
|
|
|
1319
1459
|
fileId: metadata.fileId,
|
|
1320
1460
|
tableId: request.tableId,
|
|
1321
1461
|
revision: String(metadata.revision),
|
|
1322
|
-
results
|
|
1462
|
+
results,
|
|
1463
|
+
...usesClockFilter(request.query?.filter) ? { referenceInstant: this.requestInstant } : {}
|
|
1323
1464
|
};
|
|
1324
1465
|
}
|
|
1466
|
+
bindCursorReference(reference) {
|
|
1467
|
+
const instant = normalizeEidosFileInstant(reference);
|
|
1468
|
+
if (this.requestedReference !== void 0 && this.requestedReference !== instant) throw runtimeError("invalid-query", "Cursor reference instant mismatch");
|
|
1469
|
+
this.requestInstant = instant;
|
|
1470
|
+
this.core.setRequestInstant(instant);
|
|
1471
|
+
}
|
|
1325
1472
|
compatibilityQuery(tableId, query) {
|
|
1326
1473
|
assertRuntimeRowQuery(this.core.listFields(tableId), query);
|
|
1327
|
-
|
|
1474
|
+
if (usesCalendarPeriod(query.filter)) assertEidosFileCalendarContext(this.requestCalendar);
|
|
1475
|
+
return {
|
|
1476
|
+
...runtimeQueryToCompatibility(query),
|
|
1477
|
+
...this.requestCalendar ? { calendar: this.requestCalendar } : {}
|
|
1478
|
+
};
|
|
1328
1479
|
}
|
|
1329
1480
|
async groupRowsNow(request) {
|
|
1481
|
+
if (request.cursor) {
|
|
1482
|
+
const cursor = this.decodeCursor(request.cursor, "groups");
|
|
1483
|
+
if (typeof cursor.referenceInstant === "string") this.bindCursorReference(cursor.referenceInstant);
|
|
1484
|
+
}
|
|
1330
1485
|
assertLimit(request.groupLimit, EIDOS_RUNTIME_LIMITS.groupPageSizeMax, "groupLimit");
|
|
1331
1486
|
assertLimit(request.rowsPerGroup, EIDOS_RUNTIME_LIMITS.pageSizeMax, "rowsPerGroup");
|
|
1332
1487
|
if (request.groupBy.length < 1 || request.groupBy.length > EIDOS_RUNTIME_LIMITS.groupFieldsMax || new Set(request.groupBy).size !== request.groupBy.length) throw runtimeError("invalid-query", "groupBy is invalid");
|
|
@@ -1389,7 +1544,8 @@ var EidosRuntimeService = class {
|
|
|
1389
1544
|
revision: String(metadata.revision),
|
|
1390
1545
|
projectionHash: projectionDigest,
|
|
1391
1546
|
bindingHash: bindingDigest,
|
|
1392
|
-
groupIdentity: group.identity
|
|
1547
|
+
groupIdentity: group.identity,
|
|
1548
|
+
referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment)
|
|
1393
1549
|
}) : null;
|
|
1394
1550
|
return {
|
|
1395
1551
|
fileId: metadata.fileId,
|
|
@@ -1397,6 +1553,7 @@ var EidosRuntimeService = class {
|
|
|
1397
1553
|
revision: String(metadata.revision),
|
|
1398
1554
|
projectionHash: projectionDigest,
|
|
1399
1555
|
columns,
|
|
1556
|
+
...usesClockFilter(request.query.filter) ? { referenceInstant: this.requestInstant } : {},
|
|
1400
1557
|
groups: selected.map((group) => {
|
|
1401
1558
|
const visible = group.rows.slice(0, request.rowsPerGroup);
|
|
1402
1559
|
const projected = visible.map((row) => projectionRows.get(row.id) ?? row);
|
|
@@ -1410,6 +1567,7 @@ var EidosRuntimeService = class {
|
|
|
1410
1567
|
bindingHash: bindingDigest,
|
|
1411
1568
|
request: groupCursorSource(request),
|
|
1412
1569
|
groupKey: group.key,
|
|
1570
|
+
referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
|
|
1413
1571
|
forward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, groupedQuery), row),
|
|
1414
1572
|
backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardGroupedQuery), row)
|
|
1415
1573
|
});
|
|
@@ -1457,7 +1615,8 @@ var EidosRuntimeService = class {
|
|
|
1457
1615
|
revision: String(metadata.revision),
|
|
1458
1616
|
projectionHash: projectionDigest,
|
|
1459
1617
|
bindingHash: bindingDigest,
|
|
1460
|
-
groupIdentity: group.identity
|
|
1618
|
+
groupIdentity: group.identity,
|
|
1619
|
+
referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment)
|
|
1461
1620
|
}) : null;
|
|
1462
1621
|
const groups = selected.map((group) => {
|
|
1463
1622
|
const groupedQuery = queryForGroup(request.query, request.groupBy, group.key);
|
|
@@ -1479,6 +1638,7 @@ var EidosRuntimeService = class {
|
|
|
1479
1638
|
bindingHash: bindingDigest,
|
|
1480
1639
|
request: groupCursorSource(request),
|
|
1481
1640
|
groupKey: group.key,
|
|
1641
|
+
referenceInstant: this.requestInstant ?? checkedNowInstant(this.environment),
|
|
1482
1642
|
forward: this.core.createRowCursor(request.tableId, compatibilityQuery, row),
|
|
1483
1643
|
backward: this.core.createRowCursor(request.tableId, this.compatibilityQuery(request.tableId, backwardGroupedQuery), row)
|
|
1484
1644
|
});
|
|
@@ -1496,6 +1656,7 @@ var EidosRuntimeService = class {
|
|
|
1496
1656
|
revision: String(metadata.revision),
|
|
1497
1657
|
projectionHash: projectionDigest,
|
|
1498
1658
|
columns,
|
|
1659
|
+
...usesClockFilter(request.query.filter) ? { referenceInstant: this.requestInstant } : {},
|
|
1499
1660
|
groups,
|
|
1500
1661
|
nextCursor: end < counts.length ? cursorForGroup(selected.at(-1)) : null,
|
|
1501
1662
|
previousCursor: start > 0 ? cursorForGroup(selected[0]) : null
|
|
@@ -1735,6 +1896,7 @@ var EidosRuntimeService = class {
|
|
|
1735
1896
|
if ("position" in leaf) parseSignedInt64(leaf.position, "position");
|
|
1736
1897
|
switch (leaf.kind) {
|
|
1737
1898
|
case "create-table":
|
|
1899
|
+
for (const field of leaf.fields) assertEidosFileTemporalDefault(field.kind, field.settings, field.settings?.readOnly !== true && field.settings?.writable !== false && field.settings?.isSystem !== true);
|
|
1738
1900
|
if (leaf.fields.some((field) => field.kind === "relation" || field.kind === "lookup")) forbid("relation-definition-invalid", "Relation and Lookup Fields cannot be created inside create-table");
|
|
1739
1901
|
break;
|
|
1740
1902
|
case "set-file-title":
|
|
@@ -1777,8 +1939,9 @@ var EidosRuntimeService = class {
|
|
|
1777
1939
|
}
|
|
1778
1940
|
break;
|
|
1779
1941
|
case "create-field":
|
|
1942
|
+
assertEidosFileTemporalDefault(leaf.field.kind, leaf.field.settings, leaf.field.settings?.readOnly !== true && leaf.field.settings?.writable !== false && leaf.field.settings?.isSystem !== true);
|
|
1780
1943
|
if (!tableIds.has(leaf.tableId)) forbid("dependency-blocked", "Owning Table does not exist", { tableId: leaf.tableId });
|
|
1781
|
-
if (leaf.field.kind !== "formula" && leaf.field.kind !== "lookup" && leaf.field.kind !== "relation" && leaf.field.nullable === false && this.core.countRows(leaf.tableId) > 0) forbid("non-nullability-blocked", "A populated Table cannot add a non-null scalar Field", { tableId: leaf.tableId });
|
|
1944
|
+
if (leaf.field.kind !== "formula" && leaf.field.kind !== "lookup" && leaf.field.kind !== "relation" && leaf.field.kind !== "checkbox" && leaf.field.nullable === false && this.core.countRows(leaf.tableId) > 0) forbid("non-nullability-blocked", "A populated Table cannot add a non-null scalar Field", { tableId: leaf.tableId });
|
|
1782
1945
|
break;
|
|
1783
1946
|
case "delete-field": {
|
|
1784
1947
|
const field = fieldsById.get(leaf.fieldId);
|
|
@@ -1814,8 +1977,16 @@ var EidosRuntimeService = class {
|
|
|
1814
1977
|
}
|
|
1815
1978
|
break;
|
|
1816
1979
|
}
|
|
1980
|
+
case "set-field-settings": {
|
|
1981
|
+
const field = proposedFields.get(leaf.fieldId);
|
|
1982
|
+
if (field) assertEidosFileTemporalDefault(field.type, {
|
|
1983
|
+
...field.settings,
|
|
1984
|
+
...leaf.settings
|
|
1985
|
+
}, fieldWritable(field));
|
|
1986
|
+
if (!fieldsById.has(leaf.fieldId)) forbid("dependency-blocked", "Field does not exist", { fieldId: leaf.fieldId });
|
|
1987
|
+
break;
|
|
1988
|
+
}
|
|
1817
1989
|
case "rename-field":
|
|
1818
|
-
case "set-field-settings":
|
|
1819
1990
|
case "set-field-position":
|
|
1820
1991
|
case "set-formula":
|
|
1821
1992
|
case "set-lookup":
|
|
@@ -1974,10 +2145,47 @@ var EidosRuntimeService = class {
|
|
|
1974
2145
|
tableId: field.tableId,
|
|
1975
2146
|
fieldId: leaf.fieldId
|
|
1976
2147
|
})));
|
|
2148
|
+
const nullToFalse = conversion.valueChanges.find((change) => change.code === "null-to-false");
|
|
2149
|
+
if (nullToFalse) warnings.push({
|
|
2150
|
+
code: "null-distinction-loss",
|
|
2151
|
+
severity: "warning",
|
|
2152
|
+
tableId: field.tableId,
|
|
2153
|
+
fieldId: leaf.fieldId,
|
|
2154
|
+
message: `${nullToFalse.rows} empty cells in this column will become unchecked.`
|
|
2155
|
+
});
|
|
1977
2156
|
break;
|
|
1978
2157
|
}
|
|
1979
2158
|
}
|
|
1980
2159
|
}
|
|
2160
|
+
const changedQueryFields = fields.filter((field) => {
|
|
2161
|
+
const proposed = proposedFields.get(field.id);
|
|
2162
|
+
return proposed && canonicalizeEidosFileJson(eidosFileFieldValueType(field)) !== canonicalizeEidosFileJson(eidosFileFieldValueType(proposed));
|
|
2163
|
+
});
|
|
2164
|
+
if (changedQueryFields.length > 0) for (const view of this.allViews()) {
|
|
2165
|
+
if (view.queryStatus === "unsupported") continue;
|
|
2166
|
+
const dependency = changedQueryFields.find((field) => field.tableId === view.tableId && (view.sorts.some((sort) => sort.field === field.id) || compatibilityFilterReferencesField(view.filter, field.id)));
|
|
2167
|
+
if (!dependency) continue;
|
|
2168
|
+
dependencies.set("view:" + view.id, {
|
|
2169
|
+
object: "view",
|
|
2170
|
+
id: view.id
|
|
2171
|
+
});
|
|
2172
|
+
try {
|
|
2173
|
+
assertRuntimeRowQuery(proposedByTable.get(view.tableId) ?? [], {
|
|
2174
|
+
...view.filter ? { filter: compatibilityFilterToRuntime(view.filter, fields) } : {},
|
|
2175
|
+
sort: view.sorts.map((sort) => ({
|
|
2176
|
+
fieldId: sort.field,
|
|
2177
|
+
direction: sort.direction,
|
|
2178
|
+
...sort.nulls ? { nulls: sort.nulls } : {}
|
|
2179
|
+
}))
|
|
2180
|
+
});
|
|
2181
|
+
} catch {
|
|
2182
|
+
forbid("dependency-blocked", `Saved View “${view.name}” has a filter or sort that is incompatible with the new field type. Update or remove it before changing the field type.`, {
|
|
2183
|
+
tableId: view.tableId,
|
|
2184
|
+
fieldId: dependency.id,
|
|
2185
|
+
viewId: view.id
|
|
2186
|
+
});
|
|
2187
|
+
}
|
|
2188
|
+
}
|
|
1981
2189
|
for (const [tableId, contentFieldId] of proposedContentFields) {
|
|
1982
2190
|
if (contentFieldId === null) continue;
|
|
1983
2191
|
const field = proposedFields.get(contentFieldId);
|
|
@@ -2173,6 +2381,7 @@ var EidosRuntimeService = class {
|
|
|
2173
2381
|
...field.settings ?? {},
|
|
2174
2382
|
...leaf.settings
|
|
2175
2383
|
};
|
|
2384
|
+
if (assertEidosFileTemporalDefault(field.type, settings, fieldWritable(field)) === "now") enableTemporalDefaultsFeature(this.core.connection);
|
|
2176
2385
|
this.core.connection.run("UPDATE eidos__fields SET settings_json=? WHERE id=? AND settings_json IS NOT ?", [
|
|
2177
2386
|
canonicalizeEidosFileJson(settings),
|
|
2178
2387
|
leaf.fieldId,
|
|
@@ -2349,7 +2558,7 @@ var EidosRuntimeService = class {
|
|
|
2349
2558
|
assertWritable(operation) {
|
|
2350
2559
|
if (!this.writable) throw runtimeError("unsupported", operation + " is unavailable read-only");
|
|
2351
2560
|
}
|
|
2352
|
-
invoke(context, operation, allowClosing = false, requestPayload, accountResponse = true) {
|
|
2561
|
+
invoke(context, operation, allowClosing = false, requestPayload, accountResponse = true, acceptCalendarExecution = false, checkReadCompletion = false) {
|
|
2353
2562
|
try {
|
|
2354
2563
|
assertRequestContext(context);
|
|
2355
2564
|
if (requestPayload !== void 0) assertJcsBytes(requestPayload, EIDOS_RUNTIME_LIMITS.requestBytesMax, "Runtime request");
|
|
@@ -2370,7 +2579,16 @@ var EidosRuntimeService = class {
|
|
|
2370
2579
|
const execute = async () => {
|
|
2371
2580
|
try {
|
|
2372
2581
|
if (!allowClosing) this.checkControl(context, control, acceptedAt);
|
|
2582
|
+
const calendar = acceptCalendarExecution && requestPayload && typeof requestPayload === "object" && "calendar" in requestPayload ? requestPayload.calendar : void 0;
|
|
2583
|
+
if (calendar !== void 0) assertEidosFileCalendarContext(calendar);
|
|
2584
|
+
this.requestCalendar = calendar;
|
|
2585
|
+
const reference = acceptCalendarExecution && requestPayload && typeof requestPayload === "object" && "referenceInstant" in requestPayload ? requestPayload.referenceInstant : void 0;
|
|
2586
|
+
if (reference !== void 0 && !isCanonicalEidosFileInstant(reference)) throw runtimeError("invalid-query", "referenceInstant must be a canonical UTC instant");
|
|
2587
|
+
this.requestedReference = reference;
|
|
2588
|
+
this.requestInstant = reference ?? checkedNowInstant(this.environment);
|
|
2589
|
+
this.core.setRequestInstant(this.requestInstant);
|
|
2373
2590
|
const result = await operation();
|
|
2591
|
+
if (checkReadCompletion) this.checkControl(context, control, acceptedAt);
|
|
2374
2592
|
if (result !== void 0 && accountResponse) assertJcsBytes(result, EIDOS_RUNTIME_LIMITS.responseBytesMax, "Runtime response");
|
|
2375
2593
|
return result;
|
|
2376
2594
|
} catch (error) {
|
|
@@ -2378,6 +2596,10 @@ var EidosRuntimeService = class {
|
|
|
2378
2596
|
if (failure.code === "fatal" || failure.code === "unknown-commit") this.state = "fatal";
|
|
2379
2597
|
throw failure;
|
|
2380
2598
|
} finally {
|
|
2599
|
+
this.core.setRequestInstant();
|
|
2600
|
+
this.requestInstant = void 0;
|
|
2601
|
+
this.requestCalendar = void 0;
|
|
2602
|
+
this.requestedReference = void 0;
|
|
2381
2603
|
control.unsubscribe();
|
|
2382
2604
|
this.requestControls.delete(context.requestId);
|
|
2383
2605
|
}
|
|
@@ -2482,6 +2704,29 @@ function relationDefinition(field) {
|
|
|
2482
2704
|
].includes(String(field.property.onDelete)) ? field.property.onDelete : "restrict"
|
|
2483
2705
|
};
|
|
2484
2706
|
}
|
|
2707
|
+
function usesCalendarPeriod(node) {
|
|
2708
|
+
if (!node) return false;
|
|
2709
|
+
if (node.op === "calendar-period" || node.op === "calendar-window") return true;
|
|
2710
|
+
if (node.op === "not") return usesCalendarPeriod(node.arg);
|
|
2711
|
+
return (node.op === "and" || node.op === "or") && node.args.some(usesCalendarPeriod);
|
|
2712
|
+
}
|
|
2713
|
+
function usesClockFilter(node) {
|
|
2714
|
+
if (!node) return false;
|
|
2715
|
+
if (node.op === "calendar-period" || node.op === "calendar-window") return true;
|
|
2716
|
+
if (node.op === "not") return usesClockFilter(node.arg);
|
|
2717
|
+
if (node.op === "and" || node.op === "or") return node.args.some(usesClockFilter);
|
|
2718
|
+
return false;
|
|
2719
|
+
}
|
|
2720
|
+
function isPublicSavedQueryDocument(query) {
|
|
2721
|
+
const visit = (value) => {
|
|
2722
|
+
if (!value || typeof value !== "object" || Array.isArray(value)) return false;
|
|
2723
|
+
const node = value;
|
|
2724
|
+
if (node.op === "not") return visit(node.arg);
|
|
2725
|
+
if (node.op === "and" || node.op === "or") return Array.isArray(node.args) && node.args.every(visit);
|
|
2726
|
+
return typeof node.fieldId === "string";
|
|
2727
|
+
};
|
|
2728
|
+
return (query.filter === void 0 || visit(query.filter)) && (query.sort === void 0 || Array.isArray(query.sort) && query.sort.every((sort) => sort && typeof sort === "object" && typeof sort.fieldId === "string"));
|
|
2729
|
+
}
|
|
2485
2730
|
function normalizedRuntimeQuery(query) {
|
|
2486
2731
|
return objectValue({
|
|
2487
2732
|
...query.filter === void 0 ? {} : { filter: query.filter },
|
|
@@ -2559,8 +2804,17 @@ function runtimeListElementType(type) {
|
|
|
2559
2804
|
if (type === "relation") return "row-id";
|
|
2560
2805
|
if (type === "file") return "file-entry";
|
|
2561
2806
|
}
|
|
2807
|
+
function assertRuntimeSavedViewQuery(fields, query) {
|
|
2808
|
+
if (!query || typeof query !== "object" || Array.isArray(query) || Object.keys(query).some((key) => key !== "filter" && key !== "sort")) throw runtimeError("invalid-query", "SavedViewQuery contains execution settings or unknown members");
|
|
2809
|
+
assertRuntimeRowQuery(fields, query);
|
|
2810
|
+
}
|
|
2562
2811
|
function assertRuntimeRowQuery(fields, query) {
|
|
2563
2812
|
if (!query || typeof query !== "object" || Array.isArray(query)) throw runtimeError("invalid-query", "RowQuery must be an object");
|
|
2813
|
+
if (Object.keys(query).some((key) => ![
|
|
2814
|
+
"filter",
|
|
2815
|
+
"search",
|
|
2816
|
+
"sort"
|
|
2817
|
+
].includes(key))) throw runtimeError("invalid-query", "Execution settings do not belong in RowQuery");
|
|
2564
2818
|
const byId = new Map(fields.map((field) => [field.id, field]));
|
|
2565
2819
|
if (query.search !== void 0) {
|
|
2566
2820
|
if (typeof query.search.text !== "string" || new TextEncoder().encode(query.search.text).byteLength > EIDOS_RUNTIME_LIMITS.searchBytesMax || !Array.isArray(query.search.fields) || query.search.fields.length < 1 || query.search.fields.length > EIDOS_RUNTIME_LIMITS.projectionFieldsMax || new Set(query.search.fields).size !== query.search.fields.length) throw runtimeError("invalid-query", "Search request is invalid");
|
|
@@ -2597,9 +2851,56 @@ function assertRuntimeRowQuery(fields, query) {
|
|
|
2597
2851
|
if (!field) throw runtimeError("invalid-query", "Filter Field does not exist", { fieldId: node.fieldId });
|
|
2598
2852
|
const type = eidosFileFieldValueType(field);
|
|
2599
2853
|
if (node.op === "is-null" || node.op === "is-not-null") return;
|
|
2854
|
+
if (node.op === "calendar-window") {
|
|
2855
|
+
if (type !== "date" && type !== "datetime" || !isEidosFileCalendarWindowValue({
|
|
2856
|
+
direction: node.direction,
|
|
2857
|
+
unit: node.unit,
|
|
2858
|
+
count: node.count
|
|
2859
|
+
}) || Object.keys(node).some((key) => ![
|
|
2860
|
+
"op",
|
|
2861
|
+
"fieldId",
|
|
2862
|
+
"direction",
|
|
2863
|
+
"unit",
|
|
2864
|
+
"count"
|
|
2865
|
+
].includes(key))) throw runtimeError("invalid-query", "Calendar window Filter is invalid");
|
|
2866
|
+
return;
|
|
2867
|
+
}
|
|
2868
|
+
if (node.op === "calendar-period") {
|
|
2869
|
+
if (type !== "date" && type !== "datetime" || !isEidosFileCalendarPeriodValue({
|
|
2870
|
+
unit: node.unit,
|
|
2871
|
+
offset: node.offset
|
|
2872
|
+
}) || Object.keys(node).some((key) => ![
|
|
2873
|
+
"op",
|
|
2874
|
+
"fieldId",
|
|
2875
|
+
"unit",
|
|
2876
|
+
"offset"
|
|
2877
|
+
].includes(key))) throw runtimeError("invalid-query", "Calendar period Filter is invalid");
|
|
2878
|
+
return;
|
|
2879
|
+
}
|
|
2880
|
+
if (node.op === "calendar-day") {
|
|
2881
|
+
const { day, timeZone, timeZoneData } = node;
|
|
2882
|
+
if (type !== "date" && type !== "datetime" || !isEidosFileCalendarDayValue({
|
|
2883
|
+
day,
|
|
2884
|
+
timeZone,
|
|
2885
|
+
timeZoneData
|
|
2886
|
+
}) || Object.keys(node).some((key) => ![
|
|
2887
|
+
"op",
|
|
2888
|
+
"fieldId",
|
|
2889
|
+
"day",
|
|
2890
|
+
"timeZone",
|
|
2891
|
+
"timeZoneData"
|
|
2892
|
+
].includes(key))) throw runtimeError("invalid-query", "Calendar day Filter is invalid");
|
|
2893
|
+
assertEidosFileCalendarZone(timeZone, timeZoneData);
|
|
2894
|
+
throw runtimeError("unsupported", "Retired calendar-day query requires an explicit date filter upgrade");
|
|
2895
|
+
}
|
|
2600
2896
|
if (node.op === "relative-date") {
|
|
2601
2897
|
if (type !== "date" && type !== "datetime") throw runtimeError("invalid-query", "Relative date Filter requires Date or Datetime");
|
|
2602
|
-
if (![
|
|
2898
|
+
if (Object.keys(node).some((key) => ![
|
|
2899
|
+
"op",
|
|
2900
|
+
"fieldId",
|
|
2901
|
+
"direction",
|
|
2902
|
+
"unit"
|
|
2903
|
+
].includes(key)) || ![
|
|
2603
2904
|
"past",
|
|
2604
2905
|
"next",
|
|
2605
2906
|
"this"
|
|
@@ -2609,7 +2910,7 @@ function assertRuntimeRowQuery(fields, query) {
|
|
|
2609
2910
|
"month",
|
|
2610
2911
|
"year"
|
|
2611
2912
|
].includes(node.unit)) throw runtimeError("invalid-query", "Relative date Filter direction or unit is invalid");
|
|
2612
|
-
|
|
2913
|
+
throw runtimeError("unsupported", "Retired relative-date query requires an explicit date filter upgrade");
|
|
2613
2914
|
}
|
|
2614
2915
|
if (node.op === "contains" || node.op === "starts-with" || node.op === "ends-with") {
|
|
2615
2916
|
if (typeof type !== "string" || ![
|
|
@@ -2712,6 +3013,35 @@ function runtimeFilterNodeToCompatibility(node) {
|
|
|
2712
3013
|
operator: "is-between",
|
|
2713
3014
|
value: [node.lower, node.upper]
|
|
2714
3015
|
};
|
|
3016
|
+
if (node.op === "calendar-window") return {
|
|
3017
|
+
type: "rule",
|
|
3018
|
+
field: node.fieldId,
|
|
3019
|
+
operator: "is-in-calendar-window",
|
|
3020
|
+
value: {
|
|
3021
|
+
direction: node.direction,
|
|
3022
|
+
count: node.count,
|
|
3023
|
+
unit: node.unit
|
|
3024
|
+
}
|
|
3025
|
+
};
|
|
3026
|
+
if (node.op === "calendar-period") return {
|
|
3027
|
+
type: "rule",
|
|
3028
|
+
field: node.fieldId,
|
|
3029
|
+
operator: "is-in-calendar-period",
|
|
3030
|
+
value: {
|
|
3031
|
+
unit: node.unit,
|
|
3032
|
+
offset: node.offset
|
|
3033
|
+
}
|
|
3034
|
+
};
|
|
3035
|
+
if (node.op === "calendar-day") return {
|
|
3036
|
+
type: "rule",
|
|
3037
|
+
field: node.fieldId,
|
|
3038
|
+
operator: "is-on-calendar-day",
|
|
3039
|
+
value: {
|
|
3040
|
+
day: node.day,
|
|
3041
|
+
timeZone: node.timeZone,
|
|
3042
|
+
timeZoneData: node.timeZoneData
|
|
3043
|
+
}
|
|
3044
|
+
};
|
|
2715
3045
|
if (node.op === "relative-date") return {
|
|
2716
3046
|
type: "rule",
|
|
2717
3047
|
field: node.fieldId,
|
|
@@ -2799,6 +3129,30 @@ function compatibilityFilterRuleToRuntime(rule, fields) {
|
|
|
2799
3129
|
fieldId: rule.field,
|
|
2800
3130
|
values: requireValues()
|
|
2801
3131
|
};
|
|
3132
|
+
if (rule.operator === "is-in-calendar-window") {
|
|
3133
|
+
if (!isEidosFileCalendarWindowValue(rule.value)) throw runtimeError("corrupt-file", "Stored calendar window is invalid");
|
|
3134
|
+
return {
|
|
3135
|
+
op: "calendar-window",
|
|
3136
|
+
fieldId: rule.field,
|
|
3137
|
+
...rule.value
|
|
3138
|
+
};
|
|
3139
|
+
}
|
|
3140
|
+
if (rule.operator === "is-in-calendar-period") {
|
|
3141
|
+
if (!isEidosFileCalendarPeriodValue(rule.value)) throw runtimeError("corrupt-file", "Stored calendar period is invalid");
|
|
3142
|
+
return {
|
|
3143
|
+
op: "calendar-period",
|
|
3144
|
+
fieldId: rule.field,
|
|
3145
|
+
...rule.value
|
|
3146
|
+
};
|
|
3147
|
+
}
|
|
3148
|
+
if (rule.operator === "is-on-calendar-day") {
|
|
3149
|
+
if (!isEidosFileCalendarDayValue(rule.value)) throw runtimeError("corrupt-file", "Stored calendar day filter is invalid");
|
|
3150
|
+
return {
|
|
3151
|
+
op: "calendar-day",
|
|
3152
|
+
fieldId: rule.field,
|
|
3153
|
+
...rule.value
|
|
3154
|
+
};
|
|
3155
|
+
}
|
|
2802
3156
|
if (rule.operator === "is-relative-to-today") {
|
|
2803
3157
|
const relative = rule.value;
|
|
2804
3158
|
if (!relative || ![
|
|
@@ -3059,7 +3413,7 @@ function simulatedNewField(tableId, tableName, field, sequence) {
|
|
|
3059
3413
|
tableColumnName: virtual ? id : field.name,
|
|
3060
3414
|
physicalName: virtual ? null : field.name,
|
|
3061
3415
|
systemRole: null,
|
|
3062
|
-
nullable: field.kind === "formula" || field.kind === "lookup" ? true : list || field.kind === "relation" ? false : field.nullable !== false,
|
|
3416
|
+
nullable: field.kind === "formula" || field.kind === "lookup" ? true : list || field.kind === "relation" ? false : field.kind === "checkbox" ? field.nullable === true : field.nullable !== false,
|
|
3063
3417
|
isRecordLabel: false,
|
|
3064
3418
|
position: Number(field.position),
|
|
3065
3419
|
settings: field.settings ?? {},
|
|
@@ -3397,6 +3751,7 @@ function compareGroupKeys(left, right, types) {
|
|
|
3397
3751
|
function groupCursorSource(request) {
|
|
3398
3752
|
return objectValue({
|
|
3399
3753
|
tableId: request.tableId,
|
|
3754
|
+
...request.calendar ? { calendar: request.calendar } : {},
|
|
3400
3755
|
query: normalizedRuntimeQuery(request.query),
|
|
3401
3756
|
groupBy: request.groupBy,
|
|
3402
3757
|
aggregates: request.aggregates,
|
|
@@ -3428,6 +3783,7 @@ function queryForGroup(query, groupBy, key) {
|
|
|
3428
3783
|
function groupBindingHash(request) {
|
|
3429
3784
|
return hashJson({
|
|
3430
3785
|
tableId: request.tableId,
|
|
3786
|
+
...request.calendar ? { calendar: request.calendar } : {},
|
|
3431
3787
|
query: normalizedRuntimeQuery(request.query),
|
|
3432
3788
|
groupBy: request.groupBy,
|
|
3433
3789
|
aggregates: request.aggregates,
|
|
@@ -3614,6 +3970,6 @@ function jcsByteLength(value) {
|
|
|
3614
3970
|
return new TextEncoder().encode(canonicalizeEidosFileJson(value)).byteLength;
|
|
3615
3971
|
}
|
|
3616
3972
|
//#endregion
|
|
3617
|
-
export { AdapterTransportRuntimeClient, AdapterTransportServer, ConnectionPortEidosFileConnection, EIDOS_ADAPTER_TRANSPORT_LIMITS, EIDOS_FILE_APPLICATION_ID, EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, EIDOS_FILE_EXTENSION, EIDOS_FILE_FEATURES_TABLE, EIDOS_FILE_FIELDS_TABLE, EIDOS_FILE_FORMAT, EIDOS_FILE_FORMAT_VERSION, EIDOS_FILE_FORMAT_VERSION_TEXT, EIDOS_FILE_FORMULA_FIELDS_TABLE, EIDOS_FILE_FORMULA_FIELD_FUNCTION_NAMES, EIDOS_FILE_FORMULA_FUNCTION_NAMES, EIDOS_FILE_FORMULA_PROFILE, EIDOS_FILE_FORM_INPUT_FIELD_TYPES, EIDOS_FILE_FORM_VIEW_TYPE, EIDOS_FILE_LOOKUP_FIELDS_TABLE, EIDOS_FILE_META_TABLE, EIDOS_FILE_MIME_TYPE, EIDOS_FILE_RELATION_FIELDS_TABLE, EIDOS_FILE_REQUIRED_TABLES, EIDOS_FILE_SCHEMA_SQL, EIDOS_FILE_SCHEMA_VERSION, EIDOS_FILE_SYSTEM_COLUMNS, EIDOS_FILE_TABLES_TABLE, EIDOS_FILE_VIEWS_TABLE, EIDOS_RUNTIME_LIMITS, EIDOS_SYSTEM_METADATA_TABLES, EidosAdapterError, EidosFileError, EidosFileHandlerRegistry, EidosFileHostError, EidosFileRuntime, EidosFileRuntimeDataSource, EidosFileSession, EidosRuntimeService, EidosUuidV7Generator, MUTABLE_BASE_FIELD_TYPES, MemoryByteSource, Runtime, SQLITE_HEADER, SQLiteWasmConnectionPort, assertEidosFileColumnName, assertEidosFileDisplayName, assertEidosFileFormulaProfile, assertEidosFileMultiSelectHasNoDefaultOption, assertEidosFileRowQuery, assertEidosFileSelectDefaultOption, assertEidosFileSelectOptions, assertEidosFileTableId, assertEidosFileTableName, assertEidosFileUuid, assertEidosFileValues, assertInt64Decimal, assertUnicodeString, cancellationPortFromSignal, canonicalizeEidosFileJson, compileEidosFileFormula, compileEidosFileFormulaFields, compileEidosFileFormulaSource, compileEidosFileRowQuery, configureEidosFileConnection, configuredTypeRef, createEidosFileCsvImportPlan, createEidosFileCsvRowEncoder, createEidosFileIdentifier, createEidosFileUuid, currentEidosFileInstant, decodeEidosFileAttachmentPaths, decodeEidosFileJsonArray, decodeEidosFileMultiSelectValues, decodeEidosFileRelationDisplay, decodeEidosFileRelationIds, decodeEidosFileStringArray, decodeEidosFileValues, eidosFileColumnStatLabel, eidosFileColumnStatTypesForField, eidosFileConversionCanReusePhysicalColumn, eidosFileConversionTargetNullable, eidosFileCsvExportHeader, eidosFileCsvRowToEidosFileRow, eidosFileFieldConversionMayRequireLossyConfirmation, eidosFileFieldDisplayValues, eidosFileFieldQueryCapabilities, eidosFileFieldStoresJsonArray, eidosFileFieldValueType, eidosFileFormViewFields, eidosFileFormViewProperties, eidosFileFormulaReferences, eidosFileLookupAggregateSupportsTarget, eidosFileLookupDisplayType, eidosFileLookupElementType, eidosFileLookupStorageCodec, eidosFileLookupTargetDisplayType, eidosFileLookupTargetValueType, eidosFileLookupValueType, eidosFileRowQueryAffectedByFieldChanges, eidosFileRowQueryPredicateColumns, eidosFileRowQuerySearchFields, eidosFileSnapshot, eidosFileSortExpression, eidosFileTextMultiSelectChoices, eidosFileTypeHandler, eidosFileTypeRefQueryCapabilities, eidosFileUriClass, encodeEidosFileAttachmentPaths, encodeEidosFileCsvRecord, encodeEidosFileJsonArray, encodeEidosFileMultiSelectValues, encodeEidosFileRelationIds, encodeEidosFileValues, hasEidosFileSqliteHeader, importEidosFileCsv, incrementEidosFileRevision, initializeEidosFileSchema, isCanonicalEidosFileDate, isCanonicalEidosFileInstant, isCanonicalEidosFileJson, isEidosFileFilterOperator, isEidosFileFormInputField, isEidosFileReservedTableName, isEidosFileUriReference, isEidosFileUuid, isMutableEidosFileFieldType, isSafeEidosFileUri, mergeEidosFilePluginConfig, mergeEidosSystemMetadata, nativeToSqlValue, normalizeEidosFileAttachmentPath, normalizeEidosFileDate, normalizeEidosFileFilter, normalizeEidosFileInstant, normalizeEidosFileRowQuery, normalizeEidosFileSorts, parseEidosFileCsvRows, parseEidosFileJson, parseEidosFileSelectDefaultOption, parseEidosFileSelectOptions, parseNonNegativeInt64, planCanonicalFieldConversion, planEidosFileCsvImport, planEidosFileFieldConversion, prepareEidosFileCsvImport, quoteIdentifier, readEidosFilePluginConfig, recommendedEidosFileConversionPolicies, removeEidosFileFilterField, rewriteEidosFileFormulaFieldReferences, setEidosFileMetadata, sqlValueToNative, transportFitsHostLimit, validateAdapterCarrier, validateAdapterEnvelope, validateEidosFile };
|
|
3973
|
+
export { AdapterTransportRuntimeClient, AdapterTransportServer, ConnectionPortEidosFileConnection, EIDOS_ADAPTER_TRANSPORT_LIMITS, EIDOS_FILE_APPLICATION_ID, EIDOS_FILE_CALENDAR_MAX_YEAR, EIDOS_FILE_CALENDAR_MIN_YEAR, EIDOS_FILE_CALENDAR_TIME_ZONE_DATA, EIDOS_FILE_CALENDAR_WINDOW_COUNT_MAX, EIDOS_FILE_CSV_INFERENCE_ROW_COUNT, EIDOS_FILE_CSV_PREVIEW_ROW_COUNT, EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT, EIDOS_FILE_DATE_QUERY_UPGRADE_RECEIPT_MAX_BYTES, EIDOS_FILE_EXTENSION, EIDOS_FILE_FEATURES_TABLE, EIDOS_FILE_FIELDS_TABLE, EIDOS_FILE_FORMAT, EIDOS_FILE_FORMAT_VERSION, EIDOS_FILE_FORMAT_VERSION_TEXT, EIDOS_FILE_FORMULA_FIELDS_TABLE, EIDOS_FILE_FORMULA_FIELD_FUNCTION_NAMES, EIDOS_FILE_FORMULA_FUNCTION_NAMES, EIDOS_FILE_FORMULA_PROFILE, EIDOS_FILE_FORM_INPUT_FIELD_TYPES, EIDOS_FILE_FORM_VIEW_TYPE, EIDOS_FILE_LOOKUP_FIELDS_TABLE, EIDOS_FILE_META_TABLE, EIDOS_FILE_MIME_TYPE, EIDOS_FILE_RELATION_FIELDS_TABLE, EIDOS_FILE_REQUIRED_TABLES, EIDOS_FILE_SCHEMA_SQL, EIDOS_FILE_SCHEMA_VERSION, EIDOS_FILE_SYSTEM_COLUMNS, EIDOS_FILE_TABLES_TABLE, EIDOS_FILE_VIEWS_TABLE, EIDOS_RUNTIME_LIMITS, EIDOS_SYSTEM_METADATA_TABLES, EidosAdapterError, EidosFileError, EidosFileHandlerRegistry, EidosFileHostError, EidosFileRuntime, EidosFileRuntimeDataSource, EidosFileSession, EidosRuntimeService, EidosUuidV7Generator, MUTABLE_BASE_FIELD_TYPES, MemoryByteSource, Runtime, SQLITE_HEADER, SQLiteWasmConnectionPort, assertEidosFileCalendarContext, assertEidosFileCalendarZone, assertEidosFileColumnName, assertEidosFileDisplayName, assertEidosFileFormulaProfile, assertEidosFileMultiSelectHasNoDefaultOption, assertEidosFileRowQuery, assertEidosFileSelectDefaultOption, assertEidosFileSelectOptions, assertEidosFileTableId, assertEidosFileTableName, assertEidosFileTemporalDefault, assertEidosFileUuid, assertEidosFileValues, assertInt64Decimal, assertUnicodeString, cancellationPortFromSignal, canonicalizeEidosFileJson, compileEidosFileFormula, compileEidosFileFormulaFields, compileEidosFileFormulaSource, compileEidosFileRowQuery, configureEidosFileConnection, configuredTypeRef, createEidosFileCsvImportPlan, createEidosFileCsvRowEncoder, createEidosFileIdentifier, createEidosFileUuid, currentEidosFileInstant, decodeEidosFileAttachmentPaths, decodeEidosFileJsonArray, decodeEidosFileMultiSelectValues, decodeEidosFileRelationDisplay, decodeEidosFileRelationIds, decodeEidosFileStringArray, decodeEidosFileValues, eidosFileCalendarDateRangeIntervals, eidosFileCalendarDayBounds, eidosFileCalendarPeriodBounds, eidosFileCalendarTimeZones, eidosFileCalendarWindowBounds, eidosFileColumnStatLabel, eidosFileColumnStatTypesForField, eidosFileConversionCanReusePhysicalColumn, eidosFileConversionTargetNullable, eidosFileCsvExportHeader, eidosFileCsvRowToEidosFileRow, eidosFileDateQueryUpgradeReceipt, eidosFileFieldConversionMayRequireLossyConfirmation, eidosFileFieldDisplayValues, eidosFileFieldQueryCapabilities, eidosFileFieldStoresJsonArray, eidosFileFieldValueType, eidosFileFormViewFields, eidosFileFormViewProperties, eidosFileFormulaReferences, eidosFileLookupAggregateSupportsTarget, eidosFileLookupDisplayType, eidosFileLookupElementType, eidosFileLookupStorageCodec, eidosFileLookupTargetDisplayType, eidosFileLookupTargetValueType, eidosFileLookupValueType, eidosFileRowQueryAffectedByFieldChanges, eidosFileRowQueryPredicateColumns, eidosFileRowQuerySearchFields, eidosFileSnapshot, eidosFileSortExpression, eidosFileTemporalDefaultValue, eidosFileTextMultiSelectChoices, eidosFileTypeHandler, eidosFileTypeRefQueryCapabilities, eidosFileUriClass, encodeEidosFileAttachmentPaths, encodeEidosFileCsvRecord, encodeEidosFileJsonArray, encodeEidosFileMultiSelectValues, encodeEidosFileRelationIds, encodeEidosFileValues, hasEidosFileCalendarPeriodQuery, hasEidosFileCalendarQuery, hasEidosFileCalendarWindowQuery, hasEidosFileSqliteHeader, hasRetiredEidosFileDateQuery, importEidosFileCsv, incrementEidosFileRevision, initializeEidosFileSchema, isCanonicalEidosFileDate, isCanonicalEidosFileInstant, isCanonicalEidosFileJson, isEidosFileCalendarDayValue, isEidosFileCalendarPeriodValue, isEidosFileCalendarWindowValue, isEidosFileFilterOperator, isEidosFileFormInputField, isEidosFileReservedTableName, isEidosFileUriReference, isEidosFileUuid, isMutableEidosFileFieldType, isSafeEidosFileUri, mergeEidosFilePluginConfig, mergeEidosSystemMetadata, nativeToSqlValue, normalizeEidosFileAttachmentPath, normalizeEidosFileDate, normalizeEidosFileFilter, normalizeEidosFileInstant, normalizeEidosFileRowQuery, normalizeEidosFileSorts, normalizeEidosSchemaMerge, parseEidosFileCsvRows, parseEidosFileJson, parseEidosFileSelectDefaultOption, parseEidosFileSelectOptions, parseNonNegativeInt64, planCanonicalFieldConversion, planEidosFileCsvImport, planEidosFileFieldConversion, planEidosSchemaMerge, prepareEidosFileCsvImport, projectEidosFileCalendarInstant, quoteIdentifier, readEidosFilePluginConfig, recommendedEidosFileConversionPolicies, removeEidosFileFilterField, resolveEidosFileCalendarInstant, rewriteEidosFileFormulaFieldReferences, setEidosFileMetadata, sqlValueToNative, supportsEidosFileCalendarProfile, transportFitsHostLimit, upgradeEidosFileDateQuery, validateAdapterCarrier, validateAdapterEnvelope, validateEidosFile };
|
|
3618
3974
|
|
|
3619
3975
|
//# sourceMappingURL=index.mjs.map
|