@owox/backend 0.35.0 → 0.36.0

package/dist/src/data-marts/calculated-fields/join-grain.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildJoinGrainSources = buildJoinGrainSources;
+exports.checkJoinGrain = checkJoinGrain;
+exports.withoutUntouchedJoinAdvisories = withoutUntouchedJoinAdvisories;
+const formula_violations_1 = require("./formula-violations");
+function buildJoinGrainSources(sources, audience) {
+    const reportable = (source) => source.isIncluded && source.isAccessibleForReporting;
+    const hidden = (source) => audience.kind === 'agent' && !reportable(source);
+    const fieldNames = (source) => {
+        if (audience.kind === 'editor')
+            return undefined;
+        if (hidden(source))
+            return new Map();
+        return new Map(audience.blendedFields
+            .filter(f => f.aliasPath === source.aliasPath && !f.isHidden)
+            .map(f => [f.originalFieldName, f.name]));
+    };
+    return new Map(sources.map(source => [
+        source.aliasPath,
+        {
+            multiplication: source.mainGrainMultiplication ?? 'unknown',
+            keyFields: source.mainGrainKeyFields ?? [],
+            collapse: source.mainGrainCollapse ?? 'collapses',
+            title: hidden(source) ? formula_violations_1.UNNAMED_JOINED_SOURCE : (source.title ?? source.aliasPath),
+            titleHidden: hidden(source),
+            uniqueCountAvailable: reportable(source) && source.uniqueCountAvailability === 'available',
+            reader: audience.kind,
+            fieldNames: fieldNames(source),
+            unprovenAt: source.mainGrainUnprovenAt,
+            multipliedAt: source.mainGrainMultipliedAt,
+            collapsedAt: source.mainGrainCollapsedAt,
+        },
+    ]));
+}
+function isLeftInPlace(call) {
+    return call.name.trim().toUpperCase() === 'COUNT' && !call.distinct;
+}
+const parentOf = (aliasPath) => aliasPath.includes('.') ? aliasPath.slice(0, aliasPath.lastIndexOf('.')) : '';
+function checkJoinGrain(input) {
+    const { fieldName, aggregateCalls, sources } = input;
+    const warnings = [];
+    const titleOf = (aliasPath) => sources.get(aliasPath)?.title ?? formula_violations_1.UNNAMED_JOINED_SOURCE;
+    const isWithheld = (aliasPath) => aliasPath !== '' && sources.get(aliasPath)?.titleHidden === true;
+    const reported = new Set();
+    for (const call of aggregateCalls) {
+        if (call.owner === '' || !isLeftInPlace(call) || reported.has(call.owner))
+            continue;
+        const source = sources.get(call.owner);
+        const reference = call.references[0];
+        if (source === undefined || reference === undefined)
+            continue;
+        if (source.multiplication === 'none' && source.collapse === 'none')
+            continue;
+        reported.add(call.owner);
+        const ref = spell(source, reference);
+        const uniqueCount = uniqueCountOffer(source);
+        if (source.multiplication === 'unknown') {
+            const at = source.unprovenAt;
+            const unprovenMart = at === undefined || isWithheld(at) ? undefined : at === '' ? 'this Data Mart' : titleOf(at);
+            warnings.push(formula_violations_1.FormulaViolations.joinedMeasureGrainUnproven(fieldName, ref, source.title, unprovenMart, source.collapse === 'collapses', uniqueCount));
+            continue;
+        }
+        if (source.multiplication === 'multiplies') {
+            const failingHop = source.multipliedAt ?? call.owner;
+            const multipliedBy = failingHop !== call.owner ? titleOf(failingHop) : undefined;
+            const key = isWithheld(parentOf(failingHop)) ? undefined : source.keyFields;
+            const rowsOf = failingHop.includes('.') ? 'its parent' : 'this Data Mart';
+            warnings.push(formula_violations_1.FormulaViolations.joinedMeasureMultiplied(fieldName, ref, source.title, key, multipliedBy, rowsOf, uniqueCount));
+            continue;
+        }
+        const collapsingHop = source.collapsedAt ?? call.owner;
+        warnings.push(formula_violations_1.FormulaViolations.joinedMeasureCollapsed(fieldName, ref, source.title, collapsingHop !== call.owner ? titleOf(collapsingHop) : undefined, uniqueCount));
+    }
+    const joinedOwners = [...new Set(aggregateCalls.map(c => c.owner))].filter(o => o !== '');
+    if (joinedOwners.length > 0) {
+        warnings.push(formula_violations_1.FormulaViolations.joinedRowsExcluded(fieldName, joinedOwners.map(titleOf)));
+    }
+    return { warnings };
+}
+function uniqueCountOffer(source) {
+    if (!source.uniqueCountAvailable)
+        return 'none';
+    return source.reader === 'agent' ? 'query' : 'report';
+}
+function spell(source, reference) {
+    if (source.fieldNames === undefined) {
+        return reference.path ? `${reference.path}.${reference.field}` : reference.field;
+    }
+    return source.fieldNames.get(reference.field);
+}
+const JOINED_ROWS_EXCLUDED = 'FORMULA_JOINED_ROWS_EXCLUDED';
+const COUNTING_ADVISORIES = new Set([
+    'FORMULA_JOINED_MEASURE_MULTIPLIED',
+    'FORMULA_JOINED_MEASURE_GRAIN_UNPROVEN',
+    'FORMULA_JOINED_MEASURE_COLLAPSED',
+]);
+function withoutUntouchedJoinAdvisories(warnings, touchedFields, primaryKeyChanged) {
+    return warnings.filter(warning => {
+        if (touchedFields.has(warning.field))
+            return true;
+        if (warning.code === JOINED_ROWS_EXCLUDED)
+            return false;
+        return !COUNTING_ADVISORIES.has(warning.code) || primaryKeyChanged;
+    });
+}
+//# sourceMappingURL=join-grain.js.map

package/dist/src/data-marts/calculated-fields/set-quantifier.d.ts

@@ -0,0 +1,8 @@
+import type { SqlToken } from './sql-token-scanner';
+export declare function readSetQuantifier(tokens: readonly SqlToken[], call: {
+    argStart: number;
+    argEnd: number;
+}): {
+    distinct: boolean;
+    valueStart: number;
+};

package/dist/src/data-marts/calculated-fields/set-quantifier.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSetQuantifier = readSetQuantifier;
+function readSetQuantifier(tokens, call) {
+    const first = tokens.find(t => t.kind !== 'comment' && t.start >= call.argStart && t.end <= call.argEnd);
+    const word = first?.kind === 'word' ? first.value.toUpperCase() : '';
+    if (first && (word === 'DISTINCT' || word === 'ALL')) {
+        return { distinct: word === 'DISTINCT', valueStart: first.end };
+    }
+    return { distinct: false, valueStart: call.argStart };
+}
+//# sourceMappingURL=set-quantifier.js.map

package/dist/src/data-marts/connector-types/connector-message/schemas/connector-message.schema.d.ts

@@ -3,27 +3,42 @@ import { ConnectorMessageType } from '../../enums/connector-message-type-enum';
 export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.LOG>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
+    metric: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodUnknown>;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.LOG;
     message: string;
     at: string;
+    value?: unknown;
+    metric?: string | undefined;
+    tags?: Record<string, unknown> | undefined;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.LOG;
     message: string;
     at: string;
+    value?: unknown;
+    metric?: string | undefined;
+    tags?: Record<string, unknown> | undefined;
+    eventType?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.STATUS>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     status: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.STATUS;
     status: number;
     at: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.STATUS;
     status: number;
     at: string;
+    eventType?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.STATE>;
     at: z.ZodString;
@@ -39,15 +54,18 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.CREDENTIALS_UPDATE>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     credentials: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.CREDENTIALS_UPDATE;
     at: string;
     credentials: Record<string, unknown>;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.CREDENTIALS_UPDATE;
     at: string;
     credentials: Record<string, unknown>;
+    eventType?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.FIELDS_UPDATE>;
     at: z.ZodString;
@@ -63,27 +81,45 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.REQUESTED_DATE>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     date: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.REQUESTED_DATE;
     date: string;
     at: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.REQUESTED_DATE;
     date: string;
     at: string;
+    eventType?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<ConnectorMessageType.STATE_UPDATE>;
+    at: z.ZodString;
+    state: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: ConnectorMessageType.STATE_UPDATE;
+    at: string;
+    state: Record<string, unknown>;
+}, {
+    type: ConnectorMessageType.STATE_UPDATE;
+    at: string;
+    state: Record<string, unknown>;
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.WARNING>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     warning: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.WARNING;
     at: string;
     warning: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.WARNING;
     at: string;
     warning: string;
+    eventType?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.UNKNOWN>;
     at: z.ZodString;
@@ -99,15 +135,18 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.ERROR>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     error: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.ERROR;
     at: string;
     error: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.ERROR;
     at: string;
     error: string;
+    eventType?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.IS_IN_PROGRESS>;
     at: z.ZodString;
@@ -125,11 +164,16 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.LOG;
     message: string;
     at: string;
+    value?: unknown;
+    metric?: string | undefined;
+    tags?: Record<string, unknown> | undefined;
+    eventType?: string | undefined;
 } | {
     toFormattedString: () => string;
     type: ConnectorMessageType.STATUS;
     status: number;
     at: string;
+    eventType?: string | undefined;
 } | {
     toFormattedString: () => string;
     type: ConnectorMessageType.STATE;
@@ -140,6 +184,7 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.CREDENTIALS_UPDATE;
     at: string;
     credentials: Record<string, unknown>;
+    eventType?: string | undefined;
 } | {
     toFormattedString: () => string;
     type: ConnectorMessageType.FIELDS_UPDATE;
@@ -150,11 +195,18 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.REQUESTED_DATE;
     date: string;
     at: string;
+    eventType?: string | undefined;
+} | {
+    toFormattedString: () => string;
+    type: ConnectorMessageType.STATE_UPDATE;
+    at: string;
+    state: Record<string, unknown>;
 } | {
     toFormattedString: () => string;
     type: ConnectorMessageType.WARNING;
     at: string;
     warning: string;
+    eventType?: string | undefined;
 } | {
     toFormattedString: () => string;
     type: ConnectorMessageType.UNKNOWN;
@@ -165,6 +217,7 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.ERROR;
     at: string;
     error: string;
+    eventType?: string | undefined;
 } | {
     toFormattedString: () => string;
     type: ConnectorMessageType.IS_IN_PROGRESS;
@@ -174,10 +227,15 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.LOG;
     message: string;
     at: string;
+    value?: unknown;
+    metric?: string | undefined;
+    tags?: Record<string, unknown> | undefined;
+    eventType?: string | undefined;
 } | {
     type: ConnectorMessageType.STATUS;
     status: number;
     at: string;
+    eventType?: string | undefined;
 } | {
     type: ConnectorMessageType.STATE;
     date: string;
@@ -186,6 +244,7 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.CREDENTIALS_UPDATE;
     at: string;
     credentials: Record<string, unknown>;
+    eventType?: string | undefined;
 } | {
     type: ConnectorMessageType.FIELDS_UPDATE;
     at: string;
@@ -194,10 +253,16 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.REQUESTED_DATE;
     date: string;
     at: string;
+    eventType?: string | undefined;
+} | {
+    type: ConnectorMessageType.STATE_UPDATE;
+    at: string;
+    state: Record<string, unknown>;
 } | {
     type: ConnectorMessageType.WARNING;
     at: string;
     warning: string;
+    eventType?: string | undefined;
 } | {
     type: ConnectorMessageType.UNKNOWN;
     message: string;
@@ -206,6 +271,7 @@ export declare const ConnectorMessageSchema: z.ZodEffects<z.ZodDiscriminatedUnio
     type: ConnectorMessageType.ERROR;
     at: string;
     error: string;
+    eventType?: string | undefined;
 } | {
     type: ConnectorMessageType.IS_IN_PROGRESS;
     status: string;

package/dist/src/data-marts/connector-types/connector-message/schemas/connector-message.schema.js

@@ -8,11 +8,20 @@ const message_state_schema_1 = require("./types/message-state.schema");
 const message_credentials_update_schema_1 = require("./types/message-credentials-update.schema");
 const message_fields_update_schema_1 = require("./types/message-fields-update.schema");
 const message_requested_date_schema_1 = require("./types/message-requested-date.schema");
+const message_state_update_schema_1 = require("./types/message-state-update.schema");
 const message_warning_schema_1 = require("./types/message-warning.schema");
 const message_unknown_schema_1 = require("./types/message-unknown.schema");
 const connector_message_type_enum_1 = require("../../enums/connector-message-type-enum");
 const message_error_schema_1 = require("./types/message-error.schema");
 const message_is_in_progress_schema_1 = require("./types/message-is-in-progress.schema");
+const EXECUTION_STATUS_LABELS = {
+    1: 'Import in progress',
+    2: 'Cleanup in progress',
+    3: 'Import done',
+    4: 'Cleanup done',
+    5: 'Error',
+};
+const statusLabel = (status) => EXECUTION_STATUS_LABELS[status] ?? String(status);
 exports.ConnectorMessageSchema = zod_1.z
     .discriminatedUnion('type', [
     message_log_schema_1.MessageLogSchema,
@@ -21,6 +30,7 @@ exports.ConnectorMessageSchema = zod_1.z
     message_credentials_update_schema_1.MessageCredentialsUpdateSchema,
     message_fields_update_schema_1.MessageFieldsUpdateSchema,
     message_requested_date_schema_1.MessageRequestedDateSchema,
+    message_state_update_schema_1.MessageStateUpdateSchema,
     message_warning_schema_1.MessageWarningSchema,
     message_unknown_schema_1.MessageUnknownSchema,
     message_error_schema_1.MessageErrorSchema,
@@ -32,7 +42,7 @@ exports.ConnectorMessageSchema = zod_1.z
             case connector_message_type_enum_1.ConnectorMessageType.LOG:
                 return `[LOG] ${data.message}`;
             case connector_message_type_enum_1.ConnectorMessageType.STATUS:
-                return `[STATUS] ${data.status}`;
+                return `[STATUS] ${statusLabel(data.status)}`;
             case connector_message_type_enum_1.ConnectorMessageType.STATE: {
                 return `[STATE] ${data.date}`;
             }
@@ -46,6 +56,8 @@ exports.ConnectorMessageSchema = zod_1.z
                 const requestedDate = new Date(data.date).toLocaleString();
                 return `[REQUESTED_DATE] ${requestedDate}`;
             }
+            case connector_message_type_enum_1.ConnectorMessageType.STATE_UPDATE:
+                return `[STATE_UPDATE] ${Object.keys(data.state).join(', ')}`;
             case connector_message_type_enum_1.ConnectorMessageType.WARNING:
                 return `[WARNING] ${data.warning}`;
             case connector_message_type_enum_1.ConnectorMessageType.ERROR:

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-credentials-update.schema.d.ts

@@ -3,14 +3,17 @@ import { ConnectorMessageType } from '../../../enums/connector-message-type-enum
 export declare const MessageCredentialsUpdateSchema: z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.CREDENTIALS_UPDATE>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     credentials: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.CREDENTIALS_UPDATE;
     at: string;
     credentials: Record<string, unknown>;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.CREDENTIALS_UPDATE;
     at: string;
     credentials: Record<string, unknown>;
+    eventType?: string | undefined;
 }>;
 export type MessageCredentialsUpdate = z.infer<typeof MessageCredentialsUpdateSchema>;

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-credentials-update.schema.js

@@ -6,6 +6,7 @@ const connector_message_type_enum_1 = require("../../../enums/connector-message-
 exports.MessageCredentialsUpdateSchema = zod_1.z.object({
     type: zod_1.z.literal(connector_message_type_enum_1.ConnectorMessageType.CREDENTIALS_UPDATE),
     at: zod_1.z.string(),
+    eventType: zod_1.z.string().optional(),
     credentials: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
 });
 //# sourceMappingURL=message-credentials-update.schema.js.map

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-error.schema.d.ts

@@ -3,14 +3,17 @@ import { ConnectorMessageType } from '../../../enums/connector-message-type-enum
 export declare const MessageErrorSchema: z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.ERROR>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     error: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.ERROR;
     at: string;
     error: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.ERROR;
     at: string;
     error: string;
+    eventType?: string | undefined;
 }>;
 export type MessageError = z.infer<typeof MessageErrorSchema>;

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-error.schema.js

@@ -6,6 +6,7 @@ const connector_message_type_enum_1 = require("../../../enums/connector-message-
 exports.MessageErrorSchema = zod_1.z.object({
     type: zod_1.z.literal(connector_message_type_enum_1.ConnectorMessageType.ERROR),
     at: zod_1.z.string(),
+    eventType: zod_1.z.string().optional(),
     error: zod_1.z.string(),
 });
 //# sourceMappingURL=message-error.schema.js.map

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-log.schema.d.ts

@@ -3,14 +3,26 @@ import { ConnectorMessageType } from '../../../enums/connector-message-type-enum
 export declare const MessageLogSchema: z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.LOG>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
+    metric: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodUnknown>;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     message: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.LOG;
     message: string;
     at: string;
+    value?: unknown;
+    metric?: string | undefined;
+    tags?: Record<string, unknown> | undefined;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.LOG;
     message: string;
     at: string;
+    value?: unknown;
+    metric?: string | undefined;
+    tags?: Record<string, unknown> | undefined;
+    eventType?: string | undefined;
 }>;
 export type MessageLog = z.infer<typeof MessageLogSchema>;

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-log.schema.js

@@ -6,6 +6,10 @@ const connector_message_type_enum_1 = require("../../../enums/connector-message-
 exports.MessageLogSchema = zod_1.z.object({
     type: zod_1.z.literal(connector_message_type_enum_1.ConnectorMessageType.LOG),
     at: zod_1.z.string(),
+    eventType: zod_1.z.string().optional(),
+    metric: zod_1.z.string().optional(),
+    value: zod_1.z.unknown().optional(),
+    tags: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
     message: zod_1.z.string(),
 });
 //# sourceMappingURL=message-log.schema.js.map

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-requested-date.schema.d.ts

@@ -3,14 +3,17 @@ import { ConnectorMessageType } from '../../../enums/connector-message-type-enum
 export declare const MessageRequestedDateSchema: z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.REQUESTED_DATE>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     date: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.REQUESTED_DATE;
     date: string;
     at: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.REQUESTED_DATE;
     date: string;
     at: string;
+    eventType?: string | undefined;
 }>;
 export type MessageRequestedDate = z.infer<typeof MessageRequestedDateSchema>;

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-requested-date.schema.js

@@ -6,6 +6,7 @@ const connector_message_type_enum_1 = require("../../../enums/connector-message-
 exports.MessageRequestedDateSchema = zod_1.z.object({
     type: zod_1.z.literal(connector_message_type_enum_1.ConnectorMessageType.REQUESTED_DATE),
     at: zod_1.z.string(),
+    eventType: zod_1.z.string().optional(),
     date: zod_1.z.string(),
 });
 //# sourceMappingURL=message-requested-date.schema.js.map

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-state-update.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ConnectorMessageType } from '../../../enums/connector-message-type-enum';
+export declare const MessageStateUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<ConnectorMessageType.STATE_UPDATE>;
+    at: z.ZodString;
+    state: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: ConnectorMessageType.STATE_UPDATE;
+    at: string;
+    state: Record<string, unknown>;
+}, {
+    type: ConnectorMessageType.STATE_UPDATE;
+    at: string;
+    state: Record<string, unknown>;
+}>;
+export type MessageStateUpdate = z.infer<typeof MessageStateUpdateSchema>;

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-state-update.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageStateUpdateSchema = void 0;
+const zod_1 = require("zod");
+const connector_message_type_enum_1 = require("../../../enums/connector-message-type-enum");
+const BACKEND_OWNED_STATE_KEYS = ['date'];
+exports.MessageStateUpdateSchema = zod_1.z.object({
+    type: zod_1.z.literal(connector_message_type_enum_1.ConnectorMessageType.STATE_UPDATE),
+    at: zod_1.z.string(),
+    state: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.unknown())
+        .refine(state => !BACKEND_OWNED_STATE_KEYS.some(key => key in state), {
+        message: `state must not contain backend-owned keys: ${BACKEND_OWNED_STATE_KEYS.join(', ')}`,
+    }),
+});
+//# sourceMappingURL=message-state-update.schema.js.map

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-status.schema.d.ts

@@ -3,14 +3,17 @@ import { ConnectorMessageType } from '../../../enums/connector-message-type-enum
 export declare const MessageStatusSchema: z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.STATUS>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     status: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.STATUS;
     status: number;
     at: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.STATUS;
     status: number;
     at: string;
+    eventType?: string | undefined;
 }>;
 export type MessageStatus = z.infer<typeof MessageStatusSchema>;

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-status.schema.js

@@ -6,6 +6,7 @@ const connector_message_type_enum_1 = require("../../../enums/connector-message-
 exports.MessageStatusSchema = zod_1.z.object({
     type: zod_1.z.literal(connector_message_type_enum_1.ConnectorMessageType.STATUS),
     at: zod_1.z.string(),
+    eventType: zod_1.z.string().optional(),
     status: zod_1.z.number(),
 });
 //# sourceMappingURL=message-status.schema.js.map

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-warning.schema.d.ts

@@ -3,14 +3,17 @@ import { ConnectorMessageType } from '../../../enums/connector-message-type-enum
 export declare const MessageWarningSchema: z.ZodObject<{
     type: z.ZodLiteral<ConnectorMessageType.WARNING>;
     at: z.ZodString;
+    eventType: z.ZodOptional<z.ZodString>;
     warning: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     type: ConnectorMessageType.WARNING;
     at: string;
     warning: string;
+    eventType?: string | undefined;
 }, {
     type: ConnectorMessageType.WARNING;
     at: string;
     warning: string;
+    eventType?: string | undefined;
 }>;
 export type MessageWarning = z.infer<typeof MessageWarningSchema>;

package/dist/src/data-marts/connector-types/connector-message/schemas/types/message-warning.schema.js

@@ -6,6 +6,7 @@ const connector_message_type_enum_1 = require("../../../enums/connector-message-
 exports.MessageWarningSchema = zod_1.z.object({
     type: zod_1.z.literal(connector_message_type_enum_1.ConnectorMessageType.WARNING),
     at: zod_1.z.string(),
+    eventType: zod_1.z.string().optional(),
     warning: zod_1.z.string(),
 });
 //# sourceMappingURL=message-warning.schema.js.map

package/dist/src/data-marts/connector-types/connector-message/services/connector-event.translator.d.ts

@@ -0,0 +1,10 @@
+export declare const NEW_EVENT_TYPES: readonly [string, string, string, string, string, string, string, string];
+export type NewEventType = (typeof NEW_EVENT_TYPES)[number];
+interface RawEvent {
+    type: unknown;
+    timestamp?: unknown;
+    [key: string]: unknown;
+}
+export declare function isNewEvent(value: unknown): value is RawEvent;
+export declare function translateNewEventToLegacy(event: RawEvent): Record<string, unknown> | null;
+export {};