@owox/backend 0.35.0 → 0.36.0

package/dist/src/data-marts/services/auto-collapse.resolver.js

@@ -27,6 +27,10 @@ function resolveAutoCollapse(report) {
         filtersIntoHaving(report.filterConfig, schemaFields)) {
         return { kind: 'none', reason: 'analyst-aggregated' };
     }
+    const optedOut = new Set(report.autoAggregationOptOut ?? []);
+    if (columns.some(name => optedOut.has(name))) {
+        return { kind: 'none', reason: 'analyst-opted-out' };
+    }
     const projectedColumns = new Set(columns);
     if ((report.sortConfig ?? []).some(rule => !projectedColumns.has(rule.column))) {
         return { kind: 'none', reason: 'sort-outside-projection' };

package/dist/src/data-marts/services/blendable-schema.service.d.ts

@@ -2,6 +2,7 @@ import { BlendableSchemaDto } from '../dto/domain/blendable-schema.dto';
 import { DataMartRelationshipService } from './data-mart-relationship.service';
 import { DataMartService } from './data-mart.service';
 import { AccessDecisionService } from './access-decision';
+import { DataMartSchema } from '../data-storage-types/data-mart-schema.type';
 import { type CalculatedFieldConfig } from '../calculated-fields/calculated-field.utils';
 import { BigQueryFieldMode } from '../data-storage-types/bigquery/enums/bigquery-field-mode.enum';
 import { IdpProjectionsFacade } from '../../idp/facades/idp-projections.facade';
@@ -35,6 +36,7 @@ export declare class BlendableSchemaService {
     constructor(relationshipService: DataMartRelationshipService, dataMartService: DataMartService, accessDecisionService: AccessDecisionService);
     computeBlendableSchema(dataMartId: string, projectId: string, accessor: BlendableSchemaAccessor, options?: {
         includeDraftTargets?: boolean;
+        unsavedMainSchemaFields?: DataMartSchema['fields'];
     }): Promise<BlendableSchemaDto>;
     private applyReportingAccess;
     private collectBlendedFields;

package/dist/src/data-marts/services/blendable-schema.service.js

@@ -67,6 +67,46 @@ function flattenSchemaFields(fields, prefix = '', includeDisconnectedFields = fa
     }
     return result;
 }
+const CLEAN_GRAIN = { multiplication: 'none', keyFields: [], collapse: 'none' };
+function worseGrain(parent, hop) {
+    const parentSide = () => {
+        const pick = parent.multiplication === 'multiplies'
+            ? parent
+            : hop.multiplication === 'multiplies'
+                ? hop
+                : parent.multiplication === 'unknown'
+                    ? parent
+                    : hop;
+        const { multiplication, keyFields, unprovenAt, multipliedAt } = pick;
+        return { multiplication, keyFields, unprovenAt, multipliedAt };
+    };
+    const collapsing = parent.collapse === 'collapses' ? parent : hop;
+    return {
+        ...parentSide(),
+        collapse: collapsing.collapse,
+        collapsedAt: collapsing.collapsedAt,
+    };
+}
+const covers = (key, primaryKey) => primaryKey.length > 0 && primaryKey.every(component => key.includes(component));
+function hopGrain(parentPrimaryKey, targetPrimaryKey, joinConditions, parentPath, aliasPath) {
+    const parentKey = joinConditions.map(c => c.sourceFieldName);
+    const targetKey = joinConditions.map(c => c.targetFieldName);
+    const collapse = covers(targetKey, targetPrimaryKey)
+        ? { collapse: 'none' }
+        : { collapse: 'collapses', collapsedAt: aliasPath };
+    if (parentPrimaryKey.length === 0) {
+        return { multiplication: 'unknown', keyFields: [], unprovenAt: parentPath, ...collapse };
+    }
+    if (covers(parentKey, parentPrimaryKey)) {
+        return { multiplication: 'none', keyFields: [], ...collapse };
+    }
+    return {
+        multiplication: 'multiplies',
+        keyFields: parentKey,
+        multipliedAt: aliasPath,
+        ...collapse,
+    };
+}
 let BlendableSchemaService = class BlendableSchemaService {
     relationshipService;
     dataMartService;
@@ -79,6 +119,7 @@ let BlendableSchemaService = class BlendableSchemaService {
     async computeBlendableSchema(dataMartId, projectId, accessor, options = {}) {
         const dataMart = await this.dataMartService.getByIdAndProjectId(dataMartId, projectId);
         const rawSchemaFields = dataMart.schema?.fields ?? [];
+        const mainPrimaryKey = (0, data_mart_schema_utils_1.declaredPrimaryKeyFields)(options.unsavedMainSchemaFields ?? rawSchemaFields);
         const nativeFields = rawSchemaFields
             .filter(f => !f.isHiddenForReporting)
             .map(f => (0, calculated_field_utils_1.isCalculatedField)(f)
@@ -114,6 +155,8 @@ let BlendableSchemaService = class BlendableSchemaService {
             depth: 1,
             storageType: dataMart.storage.type,
             includeDraftTargets: options.includeDraftTargets === true,
+            parentPrimaryKey: mainPrimaryKey,
+            parentGrain: CLEAN_GRAIN,
         });
         await this.applyReportingAccess(availableSources, projectId, accessor);
         let issueSources = availableSources;
@@ -133,6 +176,8 @@ let BlendableSchemaService = class BlendableSchemaService {
                 depth: 1,
                 storageType: dataMart.storage.type,
                 includeDraftTargets: false,
+                parentPrimaryKey: mainPrimaryKey,
+                parentGrain: CLEAN_GRAIN,
             });
             const publishedPaths = new Set(publishedSources.map(source => source.aliasPath));
             issueSources = availableSources.filter(source => publishedPaths.has(source.aliasPath));
@@ -217,6 +262,18 @@ let BlendableSchemaService = class BlendableSchemaService {
             availableSource.dataMartId = rel.targetDataMart.id;
             availableSource.uniqueCountAvailability = (0, data_mart_schema_utils_1.classifyJoinedUniqueCountAvailability)(rel.targetDataMart.schema?.fields ?? []);
             availableSource.uniqueCountKeyFields = (0, data_mart_schema_utils_1.collectPrimaryKeyRowIdentity)(rel.targetDataMart.schema?.fields ?? []);
+            const targetPrimaryKey = (0, data_mart_schema_utils_1.declaredPrimaryKeyFields)(rel.targetDataMart.schema?.fields ?? []);
+            const grain = worseGrain(ctx.parentGrain, hopGrain(ctx.parentPrimaryKey, targetPrimaryKey, rel.joinConditions, ctx.parentPath, currentPath));
+            availableSource.mainGrainMultiplication = grain.multiplication;
+            availableSource.mainGrainKeyFields = [...grain.keyFields];
+            if (grain.unprovenAt !== undefined)
+                availableSource.mainGrainUnprovenAt = grain.unprovenAt;
+            if (grain.multipliedAt !== undefined) {
+                availableSource.mainGrainMultipliedAt = grain.multipliedAt;
+            }
+            availableSource.mainGrainCollapse = grain.collapse;
+            if (grain.collapsedAt !== undefined)
+                availableSource.mainGrainCollapsedAt = grain.collapsedAt;
             ctx.availableSources.push(availableSource);
             for (const field of flatTargetFields) {
                 const fieldOverride = sourceConfig?.fields?.[field.name];
@@ -255,6 +312,8 @@ let BlendableSchemaService = class BlendableSchemaService {
                 ...ctx,
                 sourceId: rel.targetDataMart.id,
                 parentPath: currentPath,
+                parentPrimaryKey: targetPrimaryKey,
+                parentGrain: grain,
                 hiddenFieldNames: ctx.hiddenFieldNames,
                 branchDmIds: new Set([...ctx.branchDmIds, rel.targetDataMart.id]),
                 depth: ctx.depth + 1,

package/dist/src/data-marts/services/connector/connector-credential-injector.service.d.ts

@@ -11,6 +11,6 @@ export declare class ConnectorCredentialInjectorService {
     refreshCredentialsForConfig(projectId: string, connectorName: string, config: Record<string, unknown>): Promise<Record<string, unknown>>;
     private injectOAuthCredentialsRecursive;
     private refreshCredentialsRecursive;
-    injectSecrets(config: Record<string, unknown>, projectId: string): Promise<Record<string, unknown>>;
+    injectSecrets(config: Record<string, unknown>, projectId: string, connectorName: string): Promise<Record<string, unknown>>;
     private resolveMapping;
 }

package/dist/src/data-marts/services/connector/connector-credential-injector.service.js

@@ -15,6 +15,7 @@ const common_1 = require("@nestjs/common");
 const connector_source_credentials_service_1 = require("./connector-source-credentials.service");
 const connector_service_1 = require("./connector.service");
 const connector_secret_service_1 = require("./connector-secret.service");
+const connector_credential_boundary_error_1 = require("../../errors/connector-credential-boundary.error");
 const connectors_1 = require("@owox/connectors");
 const { GENERATED_REFRESH_TOKEN_CREDENTIAL_FIELD, GENERATED_REFRESH_TOKEN_CONFIG_FIELD } = connectors_1.Core;
 let ConnectorCredentialInjectorService = ConnectorCredentialInjectorService_1 = class ConnectorCredentialInjectorService {
@@ -50,6 +51,9 @@ let ConnectorCredentialInjectorService = ConnectorCredentialInjectorService_1 =
                     this.logger.warn(`OAuth credentials ${credentialId} belong to project ${credentialsEntity.projectId}, not ${projectId}. Skipping injection.`);
                     return obj;
                 }
+                if (credentialsEntity.connectorName !== connectorName) {
+                    throw new connector_credential_boundary_error_1.ConnectorCredentialBoundaryError(`OAuth credentials ${credentialId} belong to connector ${credentialsEntity.connectorName}, not ${connectorName}.`);
+                }
                 const isExpired = await this.connectorSourceCredentialsService.isExpired(credentialId);
                 if (isExpired) {
                     this.logger.warn(`OAuth tokens expired for credential ID: ${credentialId}. Connector may fail. Please re-authorize.`);
@@ -81,6 +85,9 @@ let ConnectorCredentialInjectorService = ConnectorCredentialInjectorService_1 =
                 return { ...restObj, ...resolvedConfig };
             }
             catch (error) {
+                if (error instanceof connector_credential_boundary_error_1.ConnectorCredentialBoundaryError) {
+                    throw error;
+                }
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 this.logger.error(`Failed to inject OAuth credentials for ID: ${credentialId}: ${errorMessage}`, error instanceof Error ? error.stack : undefined);
                 return obj;
@@ -108,6 +115,9 @@ let ConnectorCredentialInjectorService = ConnectorCredentialInjectorService_1 =
                 return obj;
             }
             catch (error) {
+                if (error instanceof connector_credential_boundary_error_1.ConnectorCredentialBoundaryError) {
+                    throw error;
+                }
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 this.logger.warn(`Failed to refresh credentials for ${credentialId}: ${errorMessage}. Using existing credentials.`);
                 return obj;
@@ -119,7 +129,7 @@ let ConnectorCredentialInjectorService = ConnectorCredentialInjectorService_1 =
         }
         return result;
     }
-    async injectSecrets(config, projectId) {
+    async injectSecrets(config, projectId, connectorName) {
         const secretsId = config._secrets_id;
         if (!secretsId) {
             return config;
@@ -134,6 +144,10 @@ let ConnectorCredentialInjectorService = ConnectorCredentialInjectorService_1 =
                 this.logger.warn(`Secrets ${secretsId} belong to project ${secretsEntity.projectId}, not ${projectId}. Skipping injection.`);
                 return config;
             }
+            if (secretsEntity.connectorName?.toLowerCase() !== connectorName.toLowerCase()) {
+                this.logger.warn(`Secrets ${secretsId} were saved for connector ${secretsEntity.connectorName}, not ${connectorName}. Skipping injection.`);
+                return config;
+            }
             const { _secrets_id: _, ...restConfig } = config;
             const result = JSON.parse(JSON.stringify(restConfig));
             const { [GENERATED_REFRESH_TOKEN_CREDENTIAL_FIELD]: generatedRefreshToken, ...credentials } = secretsEntity.credentials;

package/dist/src/data-marts/services/connector/connector-definition.service.d.ts

@@ -0,0 +1,59 @@
+import { Repository } from 'typeorm';
+import { ConnectorDefinition } from '../../entities/connector-definition.entity';
+import { ConnectorDefinitionVersion } from '../../entities/connector-definition-version.entity';
+import { AccessDecisionService } from '../access-decision';
+import { DataMartService } from '../data-mart.service';
+export type ConnectorDefinitionVersionSummary = Pick<ConnectorDefinitionVersion, 'id' | 'version' | 'status' | 'publishedAt'>;
+export interface PublishedConnectorVersion {
+    version: ConnectorDefinitionVersion;
+    warnings: string[];
+}
+export interface ConnectorVersionActor {
+    userId: string;
+    roles: string[];
+}
+export interface CreateConnectorDefinitionInput {
+    name: string;
+    title: string;
+    description?: string | null;
+    logo?: string | null;
+    docUrl?: string | null;
+    manifest: Record<string, unknown>;
+}
+export interface UpdateConnectorDefinitionMetadataInput {
+    title?: string;
+    description?: string | null;
+    logo?: string | null;
+    docUrl?: string | null;
+}
+export declare class ConnectorDefinitionService {
+    private readonly definitionRepo;
+    private readonly versionRepo;
+    private readonly dataMartService;
+    private readonly accessDecisionService;
+    private readonly logger;
+    constructor(definitionRepo: Repository<ConnectorDefinition>, versionRepo: Repository<ConnectorDefinitionVersion>, dataMartService: DataMartService, accessDecisionService: AccessDecisionService);
+    create(projectId: string, userId: string, input: CreateConnectorDefinitionInput): Promise<ConnectorDefinition>;
+    listByProject(projectId: string): Promise<ConnectorDefinition[]>;
+    getById(projectId: string, id: string): Promise<ConnectorDefinition>;
+    updateMetadata(projectId: string, id: string, patch: UpdateConnectorDefinitionMetadataInput): Promise<ConnectorDefinition>;
+    listVersions(projectId: string, id: string): Promise<ConnectorDefinitionVersionSummary[]>;
+    getVersion(projectId: string, id: string, version: number): Promise<ConnectorDefinitionVersion>;
+    resolveManifest(projectId: string, name: string, version?: number): Promise<Record<string, unknown>>;
+    tryResolveManifest(projectId: string, name: string, version?: number): Promise<Record<string, unknown> | null>;
+    saveDraft(projectId: string, id: string, manifest: Record<string, unknown>): Promise<ConnectorDefinitionVersion>;
+    publish(projectId: string, id: string, actor: ConnectorVersionActor): Promise<PublishedConnectorVersion>;
+    private canLockRows;
+    private assertNodesHavePrimaryKeys;
+    setActiveVersion(projectId: string, id: string, version: number, actor: ConnectorVersionActor): Promise<ConnectorDefinition>;
+    private displayFieldsOf;
+    private assertMayChangeActiveVersion;
+    getActiveVersionNumberForDef(def: ConnectorDefinition): Promise<number | null>;
+    getActiveVersionNumbersByDefId(defs: ConnectorDefinition[]): Promise<Map<string, number>>;
+    softDelete(projectId: string, id: string): Promise<void>;
+    private reportSecretCoverage;
+    private collectSecretsCarryingValues;
+    private assertManifestFitsSpawn;
+    private resolveActivePublished;
+    private assertNameAvailable;
+}