@redocly/redoc 0.133.0-next.1 → 0.133.0-next.2

package/dist/server/plugins/catalog-entities/database/consts.d.ts

@@ -0,0 +1,45 @@
+export declare const DEFAULT_CHUNK_SIZE = 20;
+export declare const MAX_LOGGED_DB_ERROR_LENGTH = 1000;
+export declare const MIN_RETRYABLE_BATCH_SIZE = 2;
+export declare const MAX_BATCH_PAYLOAD_BYTES = 500000;
+export declare const ENTITIES_UPSERT_SET: {
+    organizationId: import("drizzle-orm").SQL<unknown>;
+    projectId: import("drizzle-orm").SQL<unknown>;
+    type: import("drizzle-orm").SQL<unknown>;
+    title: import("drizzle-orm").SQL<unknown>;
+    summary: import("drizzle-orm").SQL<unknown>;
+    tags: import("drizzle-orm").SQL<unknown>;
+    metadata: import("drizzle-orm").SQL<unknown>;
+    git: import("drizzle-orm").SQL<unknown>;
+    contact: import("drizzle-orm").SQL<unknown>;
+    links: import("drizzle-orm").SQL<unknown>;
+    createdAt: import("drizzle-orm").SQL<unknown>;
+    updatedAt: import("drizzle-orm").SQL<unknown>;
+    sourceFile: import("drizzle-orm").SQL<unknown>;
+    fileHash: import("drizzle-orm").SQL<unknown>;
+    hash: import("drizzle-orm").SQL<unknown>;
+    isCurrent: import("drizzle-orm").SQL<unknown>;
+    isDefaultVersion: import("drizzle-orm").SQL<unknown>;
+    isDeleted: import("drizzle-orm").SQL<unknown>;
+    scorecardsStatus: import("drizzle-orm").SQL<unknown>;
+    lastSeenRunId: import("drizzle-orm").SQL<unknown>;
+};
+export declare const RELATIONS_UPSERT_SET: {
+    organizationId: import("drizzle-orm").SQL<unknown>;
+    projectId: import("drizzle-orm").SQL<unknown>;
+    targetToSourceRelation: import("drizzle-orm").SQL<unknown>;
+    sourceFile: import("drizzle-orm").SQL<unknown>;
+    fileHash: import("drizzle-orm").SQL<unknown>;
+    isDeleted: import("drizzle-orm").SQL<unknown>;
+    createdAt: import("drizzle-orm").SQL<unknown>;
+    updatedAt: import("drizzle-orm").SQL<unknown>;
+    lastSeenRunId: import("drizzle-orm").SQL<unknown>;
+};
+export declare const ATTRIBUTES_UPSERT_SET: {
+    organizationId: import("drizzle-orm").SQL<unknown>;
+    projectId: import("drizzle-orm").SQL<unknown>;
+    rbacTeams: import("drizzle-orm").SQL<unknown>;
+    createdAt: import("drizzle-orm").SQL<unknown>;
+    updatedAt: import("drizzle-orm").SQL<unknown>;
+};
+//# sourceMappingURL=consts.d.ts.map

package/dist/server/plugins/catalog-entities/database/consts.js

@@ -0,0 +1 @@
+import{sql as e}from"drizzle-orm";const t=20,c=1e3,a=2,l=5e5,u={organizationId:e`excluded.organization_id`,projectId:e`excluded.project_id`,type:e`excluded.type`,title:e`excluded.title`,summary:e`excluded.summary`,tags:e`excluded.tags`,metadata:e`excluded.metadata`,git:e`excluded.git`,contact:e`excluded.contact`,links:e`excluded.links`,createdAt:e`excluded.created_at`,updatedAt:e`excluded.updated_at`,sourceFile:e`excluded.source_file`,fileHash:e`excluded.file_hash`,hash:e`excluded.hash`,isCurrent:e`excluded.is_current`,isDefaultVersion:e`excluded.is_default_version`,isDeleted:e`excluded.is_deleted`,scorecardsStatus:e`excluded.scorecards_status`,lastSeenRunId:e`excluded.last_seen_run_id`},r={organizationId:e`excluded.organization_id`,projectId:e`excluded.project_id`,targetToSourceRelation:e`excluded.target_to_source_relation`,sourceFile:e`excluded.source_file`,fileHash:e`excluded.file_hash`,isDeleted:e`excluded.is_deleted`,createdAt:e`excluded.created_at`,updatedAt:e`excluded.updated_at`,lastSeenRunId:e`excluded.last_seen_run_id`},_={organizationId:e`excluded.organization_id`,projectId:e`excluded.project_id`,rbacTeams:e`excluded.rbac_teams`,createdAt:e`excluded.created_at`,updatedAt:e`excluded.updated_at`};export{_ as ATTRIBUTES_UPSERT_SET,t as DEFAULT_CHUNK_SIZE,u as ENTITIES_UPSERT_SET,l as MAX_BATCH_PAYLOAD_BYTES,c as MAX_LOGGED_DB_ERROR_LENGTH,a as MIN_RETRYABLE_BATCH_SIZE,r as RELATIONS_UPSERT_SET};

package/dist/server/plugins/catalog-entities/database/mappers/create-bff-entity.d.ts

@@ -1,4 +1,3 @@
 import type { BffCatalogEntity } from '@redocly/theme/core/types';
-import type { Row } from '@libsql/client';
-export declare function createBffEntity(entity: Row): BffCatalogEntity | null;
+export declare function createBffEntity(entity: Record<string, unknown>): BffCatalogEntity | null;
 //# sourceMappingURL=create-bff-entity.d.ts.map

package/dist/server/plugins/catalog-entities/database/mappers/create-bff-entity.js

@@ -1 +1 @@
-import{logger as o}from"../../../../tools/notifiers/logger.js";import{entityDatabaseSchema as s}from"../../schemas/database-schemas.js";import{validateWithResult as l}from"../../utils/ajv-validator.js";import{createBffRelatedEntities as n}from"./create-bff-related-entities.js";function m(t){const{domains:r,owners:i}=t,a=l(s,t);if(!a.success)return o.warn(`Invalid database catalog entity for entity ${t.key}, error: ${a.error}`),null;const e=a.data||{};return{id:e.id,organizationId:e.organization_id,projectId:e.project_id,type:e.type,key:e.key,title:e.title,summary:e.summary??void 0,tags:e.tags?JSON.parse(e.tags):null,metadata:e.metadata?JSON.parse(e.metadata):null,git:e.git?JSON.parse(e.git):null,contact:e.contact?JSON.parse(e.contact):null,links:e.links?JSON.parse(e.links):null,source:e.source,sourceFile:e.source_file??void 0,createdAt:e.created_at,updatedAt:e.updated_at,version:e.version??void 0,revision:e.revision,isCurrent:e.is_current!==null?!!e.is_current:null,isDefaultVersion:e.is_default_version!==null?!!e.is_default_version:null,isDeleted:e.is_deleted!==null?!!e.is_deleted:null,object:"catalogEntityView",domains:n(r),owners:n(i)}}export{m as createBffEntity};
+import{logger as o}from"../../../../tools/notifiers/logger.js";import{entityDatabaseSchema as s}from"../../schemas/database-schemas.js";import{validateWithResult as l}from"../../utils/ajv-validator.js";import{createBffRelatedEntities as n}from"./create-bff-related-entities.js";function f(t){const r=t.domains,i=t.owners,a=l(s,{...t});if(!a.success)return o.warn(`Invalid database catalog entity for entity ${String(t.key)}, error: ${a.error}`),null;const e=a.data||{};return{id:e.id,organizationId:e.organizationId,projectId:e.projectId,type:e.type,key:e.key,title:e.title,summary:e.summary??void 0,tags:e.tags?JSON.parse(e.tags):null,metadata:e.metadata?JSON.parse(e.metadata):null,git:e.git?JSON.parse(e.git):null,contact:e.contact?JSON.parse(e.contact):null,links:e.links?JSON.parse(e.links):null,source:e.source,sourceFile:e.sourceFile??void 0,createdAt:e.createdAt,updatedAt:e.updatedAt,version:e.version??void 0,revision:e.revision,isCurrent:e.isCurrent!==null?!!e.isCurrent:null,isDefaultVersion:e.isDefaultVersion!==null?!!e.isDefaultVersion:null,isDeleted:e.isDeleted!==null?!!e.isDeleted:null,object:"catalogEntityView",domains:n(r),owners:n(i)}}export{f as createBffEntity};

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-attributes-db-record.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseEntityAttributesDto } from '../../../../providers/database/databases/catalog-sqlite/schemas/entities-attributes-table';
+import type { DatabaseEntityAttributesDto } from '../../../../providers/database/databases/sqlite-db/schemas/entities-attributes-table.js';
 export declare function createEntityAttributesDbRecord({ rbacTeams, entityKey, organizationId, projectId, }: {
     rbacTeams: string[];
     entityKey: string;

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-db-record.d.ts

@@ -1,5 +1,5 @@
 import type { EntityBaseFileSchema } from '@redocly/config';
-import type { DatabaseEntityDto } from '../../../../providers/database/databases/catalog-sqlite/schemas/entities-table.js';
+import type { DatabaseEntityDto } from '../../../../providers/database/databases/sqlite-db/schemas/entities-table.js';
 export declare function createEntityDbRecord({ entity, organizationId, projectId, source, sourceFile, fileHash, }: {
     entity: EntityBaseFileSchema & {
         id?: string;

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-read-model.d.ts

@@ -1,5 +1,3 @@
-import type { Row } from '@libsql/client';
 import type { EntityReadModelSchema } from '../../schemas/read-model-schemas.js';
-import type { DatabaseEntity } from '../../../../providers/database/databases/catalog-sqlite/schemas/entities-table.js';
-export declare function createEntityReadModel(entity: DatabaseEntity | Row): EntityReadModelSchema | null;
+export declare function createEntityReadModel(entity: Record<string, unknown>): EntityReadModelSchema | null;
 //# sourceMappingURL=create-entity-read-model.d.ts.map

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-read-model.js

@@ -1 +1 @@
-import{logger as r}from"../../../../tools/notifiers/logger.js";import{VERSION_NOT_SPECIFIED as t}from"@redocly/theme/core/constants";import{entityDatabaseSchema as l}from"../../schemas/database-schemas.js";import{validateWithResult as o}from"../../utils/ajv-validator.js";const i=e=>"project_id"in e&&"organization_id"in e&&"created_at"in e;function m(e){if(i(e)){const s=o(l,e);if(!s.success)return r.warn(`Invalid database catalog entity for entity ${e.key}, error: ${s.error}`),null;const a=s.data||{};return{id:a.id,organizationId:a.organization_id,projectId:a.project_id,type:a.type,key:a.key||"",title:a.title||"",summary:a.summary||null,tags:a.tags?JSON.parse(a.tags):null,metadata:a.metadata?JSON.parse(a.metadata):null,git:a.git?JSON.parse(a.git):null,contact:a.contact?JSON.parse(a.contact):null,links:a.links?JSON.parse(a.links):null,source:a.source||"file",sourceFile:a.source_file||null,version:a.version||t,revision:a.revision??"",hash:a.hash||null,isCurrent:a.is_current??!1,isDefaultVersion:a.is_default_version??!1,createdAt:a.created_at,updatedAt:a.updated_at,isDeleted:a.is_deleted??!1,object:"catalogEntity",rbacTeams:a.rbac_teams?JSON.parse(a.rbac_teams):[]}}return{...e,tags:e.tags?JSON.parse(e.tags):null,metadata:e.metadata?JSON.parse(e.metadata):null,git:e.git?JSON.parse(e.git):null,contact:e.contact?JSON.parse(e.contact):null,links:e.links?JSON.parse(e.links):null,source:e.source||"file",version:e.version,revision:e.revision??"",hash:e.hash||null,isCurrent:e.isCurrent??!1,isDefaultVersion:e.isDefaultVersion??!1,isDeleted:e.isDeleted??!1,object:"catalogEntity"}}export{m as createEntityReadModel};
+import{logger as r}from"../../../../tools/notifiers/logger.js";import{VERSION_NOT_SPECIFIED as s}from"@redocly/theme/core/constants";import{entityDatabaseSchema as i}from"../../schemas/database-schemas.js";import{validateWithResult as o}from"../../utils/ajv-validator.js";function d(a){const t=o(i,{...a});if(!t.success)return r.warn(`Invalid database catalog entity for entity ${a.key}, error: ${t.error}`),null;const e=t.data||{};return{id:e.id,organizationId:e.organizationId,projectId:e.projectId,type:e.type,key:e.key||"",title:e.title||"",summary:e.summary||null,tags:e.tags?JSON.parse(e.tags):null,metadata:e.metadata?JSON.parse(e.metadata):null,git:e.git?JSON.parse(e.git):null,contact:e.contact?JSON.parse(e.contact):null,links:e.links?JSON.parse(e.links):null,source:e.source,sourceFile:e.sourceFile||null,version:e.version||s,revision:e.revision??"",hash:e.hash||null,isCurrent:e.isCurrent??!1,isDefaultVersion:e.isDefaultVersion??!1,createdAt:e.createdAt,updatedAt:e.updatedAt,isDeleted:e.isDeleted??!1,object:"catalogEntity",rbacTeams:e.rbacTeams?JSON.parse(e.rbacTeams):[]}}export{d as createEntityReadModel};

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-relation-db-record-from-dto.d.ts

@@ -1,5 +1,5 @@
 import type { EntityRelationDtoSchema } from '../../schemas/dto-schemas.js';
-import type { DatabaseEntityRelationDto } from '../../../../providers/database/databases/catalog-sqlite/schemas/entities-relations-table.js';
+import type { DatabaseEntityRelationDto } from '../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js';
 export declare function createEntityRelationDbRecordFromDto(relation: EntityRelationDtoSchema & {
     id?: string;
     createdAt?: string;

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-relation-db-record-from-file-schema.d.ts

@@ -1,5 +1,5 @@
 import type { EntityRelationFileSchema } from '@redocly/config';
-import type { DatabaseEntityRelationDto } from '../../../../providers/database/databases/catalog-sqlite/schemas/entities-relations-table.js';
+import type { DatabaseEntityRelationDto } from '../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js';
 type CreateEntityRelationDbRecordFromFileSchemaParams = {
     relation: EntityRelationFileSchema;
     sourceFile: string;

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-relation-read-model.d.ts

@@ -1,7 +1,7 @@
-import type { Row } from '@libsql/client';
-import type { DatabaseEntityRelation } from '../../../../providers/database/databases/catalog-sqlite/schemas/entities-relations-table.js';
+import type { DatabaseEntityRelation } from '../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js';
 import type { EntityRelationReadModelSchema } from '../../schemas/read-model-schemas.js';
-export declare function createEntityRelationReadModel(relation: DatabaseEntityRelation | Row | null): (EntityRelationReadModelSchema & {
+export type CreateEntityRelationReadModelInput = DatabaseEntityRelation | Record<string, unknown>;
+export declare function createEntityRelationReadModel(relation: CreateEntityRelationReadModelInput | null): (EntityRelationReadModelSchema & {
     object: 'catalogEntityRelation';
 }) | null;
 //# sourceMappingURL=create-entity-relation-read-model.d.ts.map

package/dist/server/plugins/catalog-entities/database/mappers/create-entity-relation-read-model.js

@@ -1 +1 @@
-import{logger as r}from"../../../../tools/notifiers/logger.js";import{entityRelationDatabaseSchema as i}from"../../schemas/database-schemas.js";import{validateWithResult as a}from"../../utils/ajv-validator.js";const n=e=>"project_id"in e&&"organization_id"in e&&"source_key"in e;function g(e){if(!e)return null;if(n(e)){const o=a(i,e);if(!o.success)return r.warn(`Invalid database catalog entity relation, error: ${o.error}`),null;const t=o.data||{};return{id:t.id,organizationId:t.organization_id,projectId:t.project_id,sourceKey:t.source_key,targetKey:t.target_key,sourceVersion:t.source_version??null,sourceRevision:t.source_revision??null,targetVersion:t.target_version??null,targetRevision:t.target_revision??null,type:t.source_to_target_relation,createdAt:t.created_at,updatedAt:t.updated_at,object:"catalogEntityRelation"}}return{id:e.id,organizationId:e.organizationId,projectId:e.projectId,sourceKey:e.sourceKey,targetKey:e.targetKey,sourceVersion:e.sourceVersion??null,sourceRevision:e.sourceRevision??null,targetVersion:e.targetVersion??null,targetRevision:e.targetRevision??null,type:e.sourceToTargetRelation,createdAt:e.createdAt,updatedAt:e.updatedAt,object:"catalogEntityRelation"}}export{g as createEntityRelationReadModel};
+import{logger as o}from"../../../../tools/notifiers/logger.js";import{entityRelationDatabaseSchema as a}from"../../schemas/database-schemas.js";import{validateWithResult as n}from"../../utils/ajv-validator.js";function u(r){if(!r)return null;const t=n(a,{...r});if(!t.success)return o.warn(`Invalid database catalog entity relation, error: ${t.error}`),null;const e=t.data||{};return{id:e.id,organizationId:e.organizationId,projectId:e.projectId,sourceKey:e.sourceKey,targetKey:e.targetKey,sourceVersion:e.sourceVersion??null,sourceRevision:e.sourceRevision??null,targetVersion:e.targetVersion??null,targetRevision:e.targetRevision??null,type:e.sourceToTargetRelation,lastSeenRunId:e.lastSeenRunId??null,createdAt:e.createdAt,updatedAt:e.updatedAt,object:"catalogEntityRelation"}}export{u as createEntityRelationReadModel};

package/dist/server/plugins/catalog-entities/database/repositories/{local/catalog-entities-bff-repository.d.ts → bffEntities/bff-entities-read-repository.d.ts}

@@ -1,10 +1,10 @@
 import type { BffCatalogEntity } from '@redocly/theme/core/types';
 import type { PaginationParams } from '../../../../../providers/database/pagination/schemas.js';
 import type { DatabaseClient } from '../../../../../providers/database/client.js';
-import type { ListResult } from './catalog-entities-local-read-repository.js';
-export declare class CatalogEntitiesBffRepository {
+import type { ListResult } from '../types.js';
+export declare class BffEntitiesReadRepository {
     #private;
-    constructor(db: DatabaseClient, attachedDatabasePath: string);
+    constructor(db: DatabaseClient);
     getEntitiesWithRelations({ paginationParams, rbacTeams, excludedEntities, excludedTypes, }: {
         paginationParams: PaginationParams;
         rbacTeams?: string[];
@@ -22,4 +22,4 @@ export declare class CatalogEntitiesBffRepository {
         excludedEntities?: string[];
     }): Promise<BffCatalogEntity | null>;
 }
-//# sourceMappingURL=catalog-entities-bff-repository.d.ts.map
+//# sourceMappingURL=bff-entities-read-repository.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/bffEntities/bff-entities-read-repository.js

@@ -0,0 +1,131 @@
+import{and as S,desc as q,eq as l,sql as e}from"drizzle-orm";import{logger as V}from"../../../../../tools/notifiers/logger.js";import{applyPagination as k}from"../../../../../providers/database/pagination/index.js";import{getEffectivePaginationLimit as J}from"../../../../../providers/database/pagination/limit.js";import{applyFilter as P,excludeFieldsFromFilter as z,getAllFilterFieldValues as W}from"../../../../../providers/database/pagination/filter.js";import{entitiesAttributesTable as N}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-attributes-table.js";import{entitiesRelationsTable as K}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js";import{entitiesTable as a}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{createBffEntity as L}from"../../mappers/create-bff-entity.js";import{FIELDS_TO_SELECT_FOR_ENTITY as p,FIELDS_TO_SELECT_FOR_ENTITY_RELATION as G,createEntityFieldsForSelect as D}from"../utils.js";import{buildEntitiesExclusionFilter as B}from"../utils/build-entities-exclusion-filter.js";import{buildRbacFilter as X,buildSubqueryRbacJoinAndFilter as Y}from"../utils/build-rbac-filter.js";import{buildSemanticVersionSortExpr as I}from"../utils/semantic-version-sort.js";const i={entityForKey:"e",baseEntities:"base_entities",pagedEntities:"paged_entities",combinedRelations:"combined_relations",combinedTargetEntities:"combined_target_entities",combinedTargetAttributes:"combined_target_attributes"};class ut{#t;constructor(t){this.#t=t}async getEntitiesWithRelations({paginationParams:t,rbacTeams:r,excludedEntities:n,excludedTypes:o}){const c=W(t.filter,"owners");if(c.length>0)return this.#c(t,c,r,o,n);const E=W(t.filter,"domains");return E.length>0?this.#l(t,E,r,o,n):this.#d(t,r,o,n)}async getEntityWithRelationsByKey({entityKey:t,filter:r,rbacTeams:n,excludedTypes:o,excludedEntities:c}){if(!t||t.trim()==="")return null;const E=r?.revision,u=r?.version,y=E?null:await this.#u(t,u||null),C=u??y?.version,R=E||y?.revision||null,F=B(o,c,"entities"),d=this.#t.client.select(D("entities")).from(a).leftJoin(N,l(a.key,N.entityKey)).where(S(l(a.key,t),X(n,"entities_attributes"),F)).as(i.entityForKey),g=this.#e().as(i.combinedRelations),b=this.#i(o,c).as(i.combinedTargetEntities),$=this.#s().as(i.combinedTargetAttributes),h=this.#t.client.with(d,g,b,$).select({...D(i.entityForKey),domains:this.#n(i.entityForKey,n).as("domains"),owners:this.#r(i.entityForKey,n).as("owners")}).from(d).$dynamic();R?h.where(S(l(e.raw("revision"),R),C?l(e.raw("version"),C):void 0)):(h.where(l(e.raw("is_current"),1)),h.orderBy(e`${I("version")} DESC`,e.raw("revision DESC"))),h.limit(1);const s=await h.get();return s?L(s):null}async#c(t,r,n,o,c){const E=this.#o(n,o,c),u=this.#e(),y=this.#i(o,c),C=u.as(i.combinedRelations),R=y.as(i.combinedTargetEntities),_=this.#s().as(i.combinedTargetAttributes),d=r.map(s=>e`
+        EXISTS (
+          SELECT 1 FROM (${u}) cr
+          WHERE cr.source_key = ${s}
+            AND cr.source_to_target_relation = 'owns'
+            AND cr.target_key = ${e.raw(`${i.baseEntities}.key`)}
+        )
+      `),g=d.length===1?d[0]:e`(${e.join(d,e` OR `)})`,T=W(t.filter,"domains");let b=g;if(T.length>0){const s=T.map(m=>e`
+          EXISTS (
+            SELECT 1 FROM (${u}) cr
+            JOIN (${y}) d ON d.key = ${m}
+            WHERE d.type = 'domain'
+              AND d.is_current = 1
+              AND cr.source_key = ${m}
+              AND cr.target_key = ${e.raw(`${i.baseEntities}.key`)}
+              AND cr.source_to_target_relation = 'hasParts'
+          )
+        `),f=s.length===1?s[0]:e`(${e.join(s,e` OR `)})`;b=e`(${g} AND ${f})`}const v=z(t.filter,["owners","domains"]),$={...t,filter:v,baseWhereCondition:b},h=this.#t.client.select(p).from(E.as(i.baseEntities)).$dynamic();try{const s=this.#t.client.select(p).from(E.as(i.baseEntities)).$dynamic();k(s,{...$,limit:void 0,skip:void 0,after:void 0,before:void 0});const f=this.#t.client.$count(s),m=J(t);k(h,{...$,limit:m+1});const w=h.as(i.pagedEntities),Q=this.#t.client.with(C,R,_,w).select({...D(i.pagedEntities),domains:this.#n(i.pagedEntities,n).as("domains"),owners:this.#r(i.pagedEntities,n).as("owners")}).from(w),[M,H]=await Promise.all([Q.all(),f]),O=M,j=O.length>m;return{items:O.slice(0,m).map(A=>L(A)).filter(A=>A!==null),hasMore:j,total:H}}catch(s){return V.error("Error getting entities with relations (owner optimized path): "+s.message),{items:[],hasMore:!1,total:0}}}async#l(t,r,n,o,c){const E=this.#o(n,o,c),u=this.#e(),y=this.#i(o,c),C=u.as(i.combinedRelations),R=y.as(i.combinedTargetEntities),_=this.#s().as(i.combinedTargetAttributes),d=r.map(s=>e`
+        EXISTS (
+          SELECT 1 FROM (${u}) cr
+          JOIN (${y}) d ON d.key = ${s}
+          WHERE d.type = 'domain'
+            AND d.is_current = 1
+            AND cr.source_key = ${s}
+            AND cr.target_key = ${e.raw(`${i.baseEntities}.key`)}
+            AND cr.source_to_target_relation = 'hasParts'
+        )
+      `),g=d.length===1?d[0]:e`(${e.join(d,e` OR `)})`,T=W(t.filter,"owners");let b=g;if(T.length>0){const s=T.map(m=>e`
+          EXISTS (
+            SELECT 1 FROM (${u}) cr
+            WHERE cr.source_key = ${m}
+              AND cr.source_to_target_relation = 'owns'
+              AND cr.target_key = ${e.raw(`${i.baseEntities}.key`)}
+          )
+        `),f=s.length===1?s[0]:e`(${e.join(s,e` OR `)})`;b=e`(${g} AND ${f})`}const v=z(t.filter,["domains","owners"]),$={...t,filter:v,baseWhereCondition:b},h=this.#t.client.select(p).from(E.as(i.baseEntities)).$dynamic();try{const s=this.#t.client.select(p).from(E.as(i.baseEntities)).$dynamic();k(s,{...$,limit:void 0,skip:void 0,after:void 0,before:void 0});const f=this.#t.client.$count(s),m=J(t);k(h,{...$,limit:m+1});const w=h.as(i.pagedEntities),Q=this.#t.client.with(C,R,_,w).select({...D(i.pagedEntities),domains:this.#n(i.pagedEntities,n).as("domains"),owners:this.#r(i.pagedEntities,n).as("owners")}).from(w),[M,H]=await Promise.all([Q.all(),f]),O=M,j=O.length>m;return{items:O.slice(0,m).map(A=>L(A)).filter(A=>A!==null),hasMore:j,total:H}}catch(s){return V.error("Error getting entities with relations (domain optimized path): "+s.message),{items:[],hasMore:!1,total:0}}}async#d(t,r,n,o){const c=this.#o(r,n,o),E=this.#e(),u=this.#i(n,o),y=E.as(i.combinedRelations),C=u.as(i.combinedTargetEntities),F=this.#s().as(i.combinedTargetAttributes),_=this.#t.client.select(p).from(c.as(i.baseEntities)).$dynamic(),{whereCondition:d}=P(_,t.filter);d&&_.where(d);try{const g=this.#t.client.select(p).from(c.as(i.baseEntities)).$dynamic();d&&g.where(d);const T=this.#t.client.$count(g),b=J(t);k(_,{...t,limit:b+1});const v=_.as(i.pagedEntities),$=this.#t.client.with(y,C,F,v).select({...D(i.pagedEntities),domains:this.#n(i.pagedEntities,r).as("domains"),owners:this.#r(i.pagedEntities,r).as("owners")}).from(v),[h,s]=await Promise.all([$.all(),T]),f=h,m=f.length>b;return{items:f.slice(0,b).map(w=>L(w)).filter(w=>w!==null),hasMore:m,total:s}}catch(g){return V.error("Error getting entities with relations (optimized path): "+g.message),{items:[],hasMore:!1,total:0}}}#o(t,r,n){const o=B(r,n,"entities");return this.#t.client.select(D("entities")).from(a).leftJoin(N,l(a.key,N.entityKey)).where(S(l(a.isCurrent,!0),l(a.isDeleted,!1),X(t,"entities_attributes"),o,this.#a("entities")))}#e(){return this.#t.client.select(G).from(K).where(l(K.isDeleted,!1))}#i(t,r){const n=B(t,r,"entities");return this.#t.client.select(p).from(a).where(S(l(a.isCurrent,!0),l(a.isDeleted,!1),n,this.#a("entities")))}async#u(t,r){if(r){const c=await this.#t.client.select({version:a.version,revision:a.revision}).from(a).where(S(l(a.key,t),l(a.version,r))).orderBy(q(a.revision)).limit(1).get();return c?{version:c.version||null,revision:c.revision||null}:null}const n=await this.#t.client.select({version:a.version,revision:a.revision}).from(a).where(S(l(a.key,t),l(a.isCurrent,!0),l(a.isDeleted,!1))).orderBy(e`${I("entities.version")} DESC`,q(a.revision)).limit(1).get();return n?{version:n.version||null,revision:n.revision||null}:null}#a(t){const r=e.raw(`${t}.key`),n=I(`${t}.version`),o=e.raw(`${t}.revision`),c=I("higher.version");return e`
+      NOT EXISTS (
+        SELECT 1
+        FROM entities higher
+        WHERE higher.key = ${r}
+          AND higher.is_current = 1
+          AND COALESCE(higher.is_deleted, 0) = 0
+          AND (
+            (${c}) > (${n})
+            OR (
+              (${c}) = (${n})
+              AND higher.revision > ${o}
+            )
+          )
+      )
+    `}#n(t,r){const{join:n,filter:o}=Y(r,"d.key");return e`
+      COALESCE(
+        (
+          SELECT json_group_array(
+            json_object(
+              'id', d.id,
+              'key', d.key,
+              'type', d.type,
+              'title', d.title,
+              'summary', d.summary,
+              'created_at', d.created_at,
+              'updated_at', d.updated_at,
+              'source', d.source,
+              'source_file', d.source_file
+            )
+          )
+          FROM (
+            SELECT DISTINCT d.*
+            FROM combined_relations er
+            JOIN combined_target_entities d ON d.key = er.source_key
+            ${n}
+            WHERE er.source_to_target_relation = 'hasParts'
+              AND er.target_key = ${e.raw(`${t}.key`)}
+              AND d.type = 'domain'
+              AND d.is_current = 1
+              ${o}
+              AND CASE 
+                WHEN ${e.raw(`${t}.version`)} = '' 
+                THEN er.target_version = ''
+                ELSE (er.target_version = ${e.raw(`${t}.version`)} OR er.target_version = '')
+              END
+              AND CASE 
+                WHEN ${e.raw(`${t}.revision`)} = '' 
+                THEN 1 = 1
+                ELSE (er.target_revision <= ${e.raw(`${t}.revision`)} OR er.target_revision = '')
+              END
+            LIMIT 10
+          ) d
+        ),
+        json_array()
+      )
+    `}#r(t,r){const{join:n,filter:o}=Y(r,"o.key");return e`
+      COALESCE(
+        (
+          SELECT json_group_array(
+            json_object(
+              'id', o.id,
+              'key', o.key,
+              'type', o.type,
+              'title', o.title,
+              'summary', o.summary,
+              'created_at', o.created_at,
+              'updated_at', o.updated_at,
+              'source', o.source,
+              'source_file', o.source_file
+            )
+          )
+          FROM (
+            SELECT DISTINCT o.*
+            FROM combined_relations er
+            JOIN combined_target_entities o ON o.key = er.source_key
+            ${n}
+            WHERE er.source_to_target_relation = 'owns'
+              AND er.target_key = ${e.raw(`${t}.key`)}
+              AND o.is_current = 1
+              ${o}
+              AND CASE 
+                WHEN ${e.raw(`${t}.version`)} = '' 
+                THEN er.target_version = ''
+                ELSE (er.target_version = ${e.raw(`${t}.version`)} OR er.target_version = '')
+              END
+              AND CASE 
+                WHEN ${e.raw(`${t}.revision`)} = '' 
+                THEN 1 = 1
+                ELSE (er.target_revision <= ${e.raw(`${t}.revision`)} OR er.target_revision = '')
+              END
+            LIMIT 10
+          ) o
+        ),
+        json_array()
+      )
+    `}#s(){return this.#t.client.select({entityKey:N.entityKey,rbacTeams:N.rbacTeams}).from(N)}}export{ut as BffEntitiesReadRepository};

package/dist/server/plugins/catalog-entities/database/repositories/catalog-entities-repository.d.ts

@@ -0,0 +1,26 @@
+import type { DatabaseConnection, RepositoryInstanceOptions } from '../../../../providers/database/types.js';
+import { BaseRepository } from '../../../../providers/database/base-repository.js';
+import { RelationsReadRepository } from './relations/relations-read-repository.js';
+import { RevisionRepository } from './common/revision-repository.js';
+import { BffEntitiesReadRepository } from './bffEntities/bff-entities-read-repository.js';
+import { EntitiesReadRepository } from './entities/entities-read-repository.js';
+import { EntitiesWriteRepository } from './entities/entities-write-repository.js';
+import { RelationsWriteRepository } from './relations/relations-write-repository.js';
+import { FiltersRepository } from './common/filters-repository.js';
+export declare class CatalogEntitiesRepository extends BaseRepository {
+    #private;
+    readonly entitiesRead: EntitiesReadRepository;
+    readonly entitiesWrite: EntitiesWriteRepository;
+    readonly relationsRead: RelationsReadRepository;
+    readonly relationsWrite: RelationsWriteRepository;
+    readonly bffEntitiesRead: BffEntitiesReadRepository;
+    readonly filters: FiltersRepository;
+    readonly revisions: RevisionRepository;
+    get transactionsManager(): import("../../../../providers/database/transactions-manager.js").TransactionsManager;
+    constructor(dbConnection: DatabaseConnection);
+    sync(): Promise<void>;
+    static getInstance(options: RepositoryInstanceOptions): Promise<CatalogEntitiesRepository>;
+    static recreateInstance(options: RepositoryInstanceOptions): Promise<CatalogEntitiesRepository>;
+    static resetInstance(): Promise<void>;
+}
+//# sourceMappingURL=catalog-entities-repository.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/catalog-entities-repository.js

@@ -0,0 +1 @@
+import{logger as n}from"../../../../tools/notifiers/logger.js";import{telemetryTraceStep as s}from"../../../../telemetry/helpers/trace-step.js";import{BaseRepository as a}from"../../../../providers/database/base-repository.js";import{DatabaseConnectionFactory as c}from"../../../../providers/database/database-connection-factory.js";import{RelationsReadRepository as o}from"./relations/relations-read-repository.js";import{RevisionRepository as f}from"./common/revision-repository.js";import{BffEntitiesReadRepository as m}from"./bffEntities/bff-entities-read-repository.js";import{EntitiesReadRepository as l}from"./entities/entities-read-repository.js";import{EntitiesWriteRepository as p}from"./entities/entities-write-repository.js";import{RelationsWriteRepository as w}from"./relations/relations-write-repository.js";import{FiltersRepository as h}from"./common/filters-repository.js";class e extends a{static#t;entitiesRead;entitiesWrite;relationsRead;relationsWrite;bffEntitiesRead;filters;revisions;get transactionsManager(){return this.databaseClient.transactionsManager}constructor(t){super(t),this.revisions=new f(t.client),this.bffEntitiesRead=new m(t.client),this.relationsRead=new o(t.client),this.entitiesRead=new l(t.client),this.entitiesWrite=new p(t.client,this.organizationId,this.projectId),this.relationsWrite=new w(t.client,this.organizationId,this.projectId),this.filters=new h(t.client)}async sync(){return s("catalog_entities.remote_repository.sync",async()=>{await this.databaseClient.sync()})}static async#e(t){const r=await c.create(t);if(!r)throw new Error("Failed to create db connection for catalog entities repository");return new e(r)}static async getInstance(t){return await s("catalog_entities.remote_repository.get_instance",async r=>{if(e.#t)return e.#t;try{return e.#t=await e.#e(t),e.#t}catch(i){throw n.error("Error creating db connection for catalog entities repository",i),r?.error(i),e.#t=null,i}})}static async recreateInstance(t){const r=e.#t,i=await e.#e(t);return e.#t=i,r&&await r.close(),i}static async resetInstance(){const t=e.#t;e.#t=null,t&&await t.close()}}export{e as CatalogEntitiesRepository};

package/dist/server/plugins/catalog-entities/database/repositories/common/filters-repository.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseClient } from '../../../../../providers/database/client.js';
+import type { CatalogFiltersParams, FilterOption } from '../types.js';
+export declare class FiltersRepository {
+    #private;
+    constructor(db: DatabaseClient);
+    getCatalogFilters({ entitiesTypes, emptyFilters, rbacTeams, excludedTypes, excludedEntities, }: CatalogFiltersParams): Promise<Record<string, FilterOption[]>>;
+}
+//# sourceMappingURL=filters-repository.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/common/filters-repository.js

@@ -0,0 +1,82 @@
+import{sql as _}from"drizzle-orm";import{logger as y}from"../../../../../tools/notifiers/logger.js";import{buildRbacFilterRaw as d}from"../utils/build-rbac-filter.js";class A{#e;constructor(i){this.#e=i}async getCatalogFilters({entitiesTypes:i=[],emptyFilters:t=[],rbacTeams:a,excludedTypes:s,excludedEntities:c}){try{const e={},u=t.filter(l=>l.startsWith("metadata.")),f=t.includes("domains")||t.includes("owners"),N=this.#t({entitiesTypes:i,rbacTeams:a,excludedTypes:s,excludedEntities:c,withRelations:f}),r=[];if(t.includes("type")&&r.push(`
+          SELECT 'type' AS filter_name, type AS value, COUNT(*) AS count
+          FROM filtered_entities
+          WHERE type IS NOT NULL
+          GROUP BY type
+        `),t.includes("tags")&&r.push(`
+          SELECT 'tags' AS filter_name, tag.value AS value, COUNT(DISTINCT fe.key) AS count
+          FROM filtered_entities fe, json_each(COALESCE(fe.tags, json_array())) AS tag
+          WHERE fe.tags IS NOT NULL
+            AND fe.tags != ''
+            AND tag.value IS NOT NULL
+            AND tag.value != ''
+          GROUP BY tag.value
+        `),t.includes("domains")&&r.push(`
+          SELECT 'domains' AS filter_name, cr.source_key AS value, COUNT(DISTINCT fe.key) AS count
+          FROM combined_relations cr
+          INNER JOIN filtered_entities fe ON fe.key = cr.target_key
+          INNER JOIN combined_entities ce ON ce.key = cr.source_key
+          WHERE ce.type = 'domain'
+            AND cr.source_to_target_relation = 'hasParts'
+          GROUP BY cr.source_key
+        `),t.includes("owners")&&r.push(`
+          SELECT 'owners' AS filter_name, owner_key AS value, COUNT(DISTINCT entity_key) AS count
+          FROM (
+            SELECT
+              fe.key AS entity_key,
+              CASE
+                WHEN fe.key = cr.target_key AND cr.source_to_target_relation = 'owns'
+                THEN cr.source_key
+                WHEN fe.key = cr.source_key AND cr.source_to_target_relation = 'ownedBy'
+                THEN cr.target_key
+              END AS owner_key
+            FROM combined_relations cr
+            INNER JOIN filtered_entities fe ON (
+              (cr.target_key = fe.key AND cr.source_to_target_relation = 'owns') OR
+              (cr.source_key = fe.key AND cr.source_to_target_relation = 'ownedBy')
+            )
+          ) AS entity_owners
+          INNER JOIN combined_entities ce ON ce.key = owner_key
+          WHERE owner_key IS NOT NULL
+          GROUP BY owner_key
+        `),r.length>0){const l=await this.#e.client.run(_.raw(`
+            ${N}
+            ${r.join(" UNION ALL ")}
+          `));for(const o of l.rows??[]){const n=o.filter_name,E=o.value,S=Number(o.count)||0;E&&(e[n]||(e[n]=[]),e[n].push({value:E,count:S}))}}if(u.length>0){const l=await this.#e.client.run(_`
+            ${_.raw(N)}
+            ${_.join(u.map(o=>{const n=A.#n(o);return _`
+                  SELECT
+                    ${o} AS filter_name,
+                    json_extract(metadata, ${n}) AS value,
+                    COUNT(*) AS count
+                  FROM filtered_entities
+                  WHERE metadata IS NOT NULL
+                    AND metadata != ''
+                    AND json_extract(metadata, ${n}) IS NOT NULL
+                    AND json_extract(metadata, ${n}) != ''
+                  GROUP BY 2
+                `}),_`
+UNION ALL
+`)}
+          `);for(const o of l.rows??[]){const n=o.filter_name,E=o.value,S=Number(o.count)||0;E&&(e[n]||(e[n]=[]),e[n].push({value:E,count:S}))}}return e}catch(e){return y.error("Error fetching catalog filters: "+e.message),{}}}#t({entitiesTypes:i,rbacTeams:t,excludedTypes:a,excludedEntities:s,withRelations:c=!1}){const e="entity",u="entityAttributes",f=d(t,u),N=this.#i(a,s),r=[`${e}.is_current = 1`,`${e}.is_deleted = 0`];f&&r.push(f),N&&r.push(N.replace(/ENTITY_ALIAS/g,e));const l=i.length?`SELECT * FROM combined_entities WHERE type IN (${i.map(n=>`'${n.replace(/'/g,"''")}'`).join(",")})`:"SELECT * FROM combined_entities",o=c?`,
+      combined_relations AS (
+        SELECT source_key, target_key, source_to_target_relation
+        FROM entities_relations
+        WHERE COALESCE(is_deleted, 0) = 0
+      )`:"";return`
+      WITH
+      combined_entities AS (
+        SELECT
+          ${e}.key,
+          ${e}.type,
+          ${e}.tags,
+          ${e}.metadata
+        FROM entities ${e}
+        LEFT JOIN entities_attributes ${u} ON ${u}.entity_key = ${e}.key
+        WHERE ${r.join(" AND ")}
+      ),
+      filtered_entities AS (
+        ${l}
+      )
+      ${o}
+    `}static#n(i){return`$.${i.substring(9).replace(/[^a-zA-Z0-9._-]/g,"")}`}#i(i,t){const a=[];if(i&&i.length>0){const s=i.map(c=>`'${c.replace(/'/g,"''")}'`).join(", ");a.push(`ENTITY_ALIAS.type NOT IN (${s})`)}if(t&&t.length>0){const s=t.map(c=>`'${c.replace(/'/g,"''")}'`).join(", ");a.push(`ENTITY_ALIAS.key NOT IN (${s})`)}return a.length>0?`(${a.join(" AND ")})`:null}}export{A as FiltersRepository};

package/dist/server/plugins/catalog-entities/database/repositories/common/revision-repository.d.ts

@@ -1,18 +1,17 @@
 import type { DatabaseClient } from '../../../../../providers/database/client.js';
+import type { EntityRevisionSummary } from '../../../schemas/read-model-schemas.js';
 export declare class RevisionRepository {
     #private;
-    private readonly db;
     constructor(db: DatabaseClient);
-    shouldSetNewCurrentRevision({ key, version, revision, }: {
+    getCurrentRevisionInfo({ key, version, revision, }: {
         key: string;
         version: string | null;
         revision: string | null;
-    }): Promise<boolean>;
+    }): Promise<{
+        shouldSetNewCurrentRevision: boolean;
+        hasCurrentRevision: boolean;
+    }>;
     markAllRevisionsAsNotCurrent(key: string): Promise<void>;
-    getCurrentEntityRevision(key: string): Promise<{
-        version: string;
-        revision: string;
-    } | null>;
     /**
      * Ensures that the one of the revisions has current and default version.
      */
@@ -23,5 +22,6 @@ export declare class RevisionRepository {
      * This allows creating new revisions when reverting to previous content states.
      */
     shouldSkipRevisionCreation(key: string, version: string | null, hash: string, isRootEntity?: boolean, isDeleted?: boolean): Promise<boolean>;
+    listEntityRevisions(entityKey: string, version?: string | null): Promise<EntityRevisionSummary[]>;
 }
 //# sourceMappingURL=revision-repository.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/common/revision-repository.js

@@ -1 +1 @@
-import{and as l,desc as c,eq as s,isNull as d}from"drizzle-orm";import{VERSION_NOT_SPECIFIED as h}from"@redocly/theme/core/constants";import{entitiesTable as e}from"../../../../../providers/database/databases/catalog-sqlite/schemas/entities-table.js";import{compareVersions as f}from"../../../utils/version-compare.js";import{VersionRepository as v}from"./version-repository.js";class V{db;#e;constructor(t){this.db=t,this.#e=new v(t)}async shouldSetNewCurrentRevision({key:t,version:i,revision:r}){const n=await this.getCurrentEntityRevision(t);if(!n)return!0;if(i){const u=await this.#e.doesVersionExist(t,i),o=f(i,n.version)>0,a=n.version===h&&i!==h;if(!u&&(o||a))return!0}return!!(i&&r&&i===n.version&&r>=n.revision)}async markAllRevisionsAsNotCurrent(t){await this.db.client.update(e).set({isCurrent:!1}).where(s(e.key,t)).run()}async getCurrentEntityRevision(t){return await this.db.client.select({version:e.version,revision:e.revision}).from(e).where(l(s(e.key,t),s(e.isCurrent,!0))).orderBy(c(e.revision)).limit(1).get()??null}async ensureDefaultAndCurrentRevisionForKey(t){const i=await this.#e.getOrderedVersionListForKey(t),r=this.#e.getLatestVersion(i);r&&await this.db.client.update(e).set({isDefaultVersion:!0,isCurrent:!0}).where(l(s(e.key,t),s(e.revision,r.revision),r.version?s(e.version,r.version):d(e.version))).run()}async shouldSkipRevisionCreation(t,i,r,n,u){if(n||u)return!1;const o=await this.db.client.select({hash:e.hash,isDeleted:e.isDeleted}).from(e).where(l(s(e.key,t),i?s(e.version,i):d(e.version))).orderBy(c(e.revision)).limit(1).run();if(o.rows.length===0)return!1;const a=o.rows[0];return a.is_deleted?!1:a.hash===r}}export{V as RevisionRepository};
+import{and as u,desc as v,eq as n,isNull as c,sql as d}from"drizzle-orm";import{VERSION_NOT_SPECIFIED as f}from"@redocly/theme/core/constants";import{entitiesTable as e}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{compareVersions as h}from"../../../utils/version-compare.js";import{VersionRepository as m}from"./version-repository.js";import{buildSemanticVersionSortExpr as C}from"../utils/semantic-version-sort.js";import{normalizeRevisionFlags as y}from"../utils/normalize-revision-flags.js";class g{#i;#e;constructor(i){this.#e=i,this.#i=new m(i)}async getCurrentRevisionInfo({key:i,version:t,revision:r}){const o=await this.#t(i);if(!o)return{shouldSetNewCurrentRevision:!0,hasCurrentRevision:!1};if(t){const a=await this.#i.doesVersionExist(i,t),s=h(t,o.version)>0,l=o.version===f&&t!==f;if(!a&&(s||l))return{shouldSetNewCurrentRevision:!0,hasCurrentRevision:!0}}return t&&r&&t===o.version&&r>=o.revision?{shouldSetNewCurrentRevision:!0,hasCurrentRevision:!0}:{shouldSetNewCurrentRevision:!1,hasCurrentRevision:!0}}async markAllRevisionsAsNotCurrent(i){await this.#e.client.update(e).set({isCurrent:!1}).where(n(e.key,i)).run()}async ensureDefaultAndCurrentRevisionForKey(i){const t=await this.#i.getOrderedVersionListForKey(i),r=this.#i.getLatestVersion(t);r&&await this.#e.client.update(e).set({isDefaultVersion:!0,isCurrent:!0}).where(u(n(e.key,i),n(e.revision,r.revision),r.version?n(e.version,r.version):c(e.version))).run()}async shouldSkipRevisionCreation(i,t,r,o,a){if(o||a)return!1;const s=await this.#e.client.select({hash:e.hash,isDeleted:e.isDeleted}).from(e).where(u(n(e.key,i),t?n(e.version,t):c(e.version))).orderBy(v(e.revision)).limit(1).get();return!s||!!s.isDeleted?!1:s.hash===r}async#t(i){return await this.#e.client.select({version:e.version,revision:e.revision}).from(e).where(u(n(e.key,i),n(e.isCurrent,!0))).orderBy(v(e.revision)).limit(1).get()??null}async listEntityRevisions(i,t){const r=[n(e.key,i),n(e.isDeleted,!1),...t?[n(e.version,t)]:[]],a=(await this.#e.client.select({version:e.version,revision:e.revision,isCurrent:e.isCurrent,createdAt:e.createdAt,updatedAt:e.updatedAt,isDefaultVersion:e.isDefaultVersion}).from(e).where(u(...r)).orderBy(d`${C("version")} DESC`,d.raw("revision DESC")).all()).map(s=>({version:s.version,revision:s.revision??"",isCurrent:s.isCurrent!==null?s.isCurrent:!1,createdAt:s.createdAt,updatedAt:s.updatedAt,isDefaultVersion:s.isDefaultVersion!==null?s.isDefaultVersion:!1}));return y(a),a}}export{g as RevisionRepository};

package/dist/server/plugins/catalog-entities/database/repositories/common/version-repository.js

@@ -1 +1 @@
-import{eq as a,and as l,desc as c}from"drizzle-orm";import{VERSION_NOT_SPECIFIED as f}from"@redocly/theme/core/constants";import{entitiesTable as e}from"../../../../../providers/database/databases/catalog-sqlite/schemas/entities-table.js";import{compareVersionsDescending as m}from"../../../utils/version-compare.js";class p{db;constructor(t){this.db=t}async markAllVersionsAsNotDefault(t){await this.db.client.update(e).set({isDefaultVersion:!1}).where(l(a(e.key,t),a(e.isDefaultVersion,!0))).run()}async doesVersionExist(t,n){return await this.db.client.select().from(e).where(l(a(e.key,t),a(e.version,n))).get()!==void 0}async getOrderedVersionListForKey(t){return(await this.db.client.select({version:e.version,isDefaultVersion:e.isDefaultVersion,revision:e.revision,createdAt:e.createdAt}).from(e).where(l(a(e.key,t))).orderBy(c(e.createdAt)).run()).rows.map(i=>({version:i.version,isDefaultVersion:!!i.isDefaultVersion,revision:i.revision,createdAt:new Date(i.createdAt)}))}getLatestVersion(t){const n=t.find(r=>r.isDefaultVersion);if(n)return n;const{versionedEntities:i,unversionedEntities:d}=t.reduce((r,s)=>(s.version!==null&&s.version!==f?r.versionedEntities.push(s):r.unversionedEntities.push(s),r),{versionedEntities:[],unversionedEntities:[]});if(i.length>0){i.sort((o,u)=>m(o.version,u.version));const r=i[0].version,s=i.filter(o=>o.version===r);return s.sort((o,u)=>u.createdAt.getTime()-o.createdAt.getTime()),s[0]}return d.length>0?(d.sort((r,s)=>s.createdAt.getTime()-r.createdAt.getTime()),d[0]):null}}export{p as VersionRepository};
+import{eq as a,and as u,desc as c}from"drizzle-orm";import{VERSION_NOT_SPECIFIED as f}from"@redocly/theme/core/constants";import{entitiesTable as e}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{compareVersionsDescending as m}from"../../../utils/version-compare.js";class p{db;constructor(t){this.db=t}async markAllVersionsAsNotDefault(t){await this.db.client.update(e).set({isDefaultVersion:!1}).where(u(a(e.key,t),a(e.isDefaultVersion,!0))).run()}async doesVersionExist(t,n){return await this.db.client.select().from(e).where(u(a(e.key,t),a(e.version,n))).get()!==void 0}async getOrderedVersionListForKey(t){return(await this.db.client.select({version:e.version,isDefaultVersion:e.isDefaultVersion,revision:e.revision,createdAt:e.createdAt}).from(e).where(u(a(e.key,t))).orderBy(c(e.createdAt)).all()).map(i=>({version:i.version,isDefaultVersion:!!i.isDefaultVersion,revision:i.revision,createdAt:new Date(i.createdAt)}))}getLatestVersion(t){const n=t.find(r=>r.isDefaultVersion);if(n)return n;const{versionedEntities:i,unversionedEntities:d}=t.reduce((r,s)=>(s.version!==null&&s.version!==f?r.versionedEntities.push(s):r.unversionedEntities.push(s),r),{versionedEntities:[],unversionedEntities:[]});if(i.length>0){i.sort((o,l)=>m(o.version,l.version));const r=i[0].version,s=i.filter(o=>o.version===r);return s.sort((o,l)=>l.createdAt.getTime()-o.createdAt.getTime()),s[0]}return d.length>0?(d.sort((r,s)=>s.createdAt.getTime()-r.createdAt.getTime()),d[0]):null}}export{p as VersionRepository};

package/dist/server/plugins/catalog-entities/database/repositories/entities/entities-read-repository.d.ts

@@ -0,0 +1,27 @@
+import type { DatabaseClient } from '../../../../../providers/database/client';
+import type { ListResult } from '../types';
+import type { EntityReadModelSchema, EntitySource } from '../../../schemas/read-model-schemas';
+import type { PaginationParams } from '../../../../../providers/database/pagination/schemas';
+import type { Filter } from '../../../../../providers/database/pagination/types';
+import type { GetEntityByIdParams } from '../../../types/params';
+export declare class EntitiesReadRepository {
+    #private;
+    constructor(db: DatabaseClient);
+    getEntities({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
+        paginationParams: PaginationParams;
+        rbacTeams?: string[];
+        excludedTypes?: string[];
+        excludedEntities?: string[];
+    }): Promise<ListResult<EntityReadModelSchema>>;
+    getEntityById(id: string, params?: GetEntityByIdParams): Promise<EntityReadModelSchema | null>;
+    getEntityKeysAndVersionsBySourceFile(sourceFile: string): Promise<Set<string>>;
+    getEntitiesCountByTypes(): Promise<{
+        type: string;
+        count: number;
+    }[]>;
+    getOutdatedEntities(filter?: Filter): Promise<EntityReadModelSchema[]>;
+    getEntitiesCount(source: EntitySource, addedEntities?: EntityReadModelSchema[], entitiesRemovedCount?: number): Promise<{
+        total: number;
+    }>;
+}
+//# sourceMappingURL=entities-read-repository.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/entities/entities-read-repository.js

@@ -0,0 +1 @@
+import{and as a,count as h,eq as l,isNotNull as R,or as A,sql as u}from"drizzle-orm";import{applyPagination as g}from"../../../../../providers/database/pagination/index.js";import{getEffectivePaginationLimit as D}from"../../../../../providers/database/pagination/limit.js";import{entitiesTable as t}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{entitiesAttributesTable as m}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-attributes-table.js";import{VERSION_NOT_SPECIFIED as L}from"@redocly/theme/core/constants";import{applyFilter as B}from"../../../../../providers/database/pagination/filter.js";import{getFirstRunRow as O}from"../../../../../providers/database/utils/get-first-row.js";import{logger as v}from"../../../../../tools/notifiers/logger.js";import{createEntityReadModel as f}from"../../mappers/create-entity-read-model.js";import{createEntityFieldsForSelect as w,FIELDS_TO_SELECT_FOR_ENTITY as E}from"../utils.js";import{buildRbacFilter as b}from"../utils/build-rbac-filter.js";import{buildEntitiesExclusionFilter as F}from"../utils/build-entities-exclusion-filter.js";class G{#t;constructor(e){this.#t=e}async getEntities({paginationParams:e,rbacTeams:i,excludedTypes:n,excludedEntities:r}){const s=F(n,r,"entities"),o=this.#t.client.select(w("entities")).from(t).leftJoin(m,l(t.key,m.entityKey)).where(a(b(i,"entities_attributes"),s)),c=this.#t.client.select(E).from(o.as("combined_entities")),S=this.#t.client.select(E).from(o.as("combined_entities")).$dynamic(),T=g(S,{...e,limit:void 0,skip:void 0,after:void 0,before:void 0}),$=this.#t.client.$count(T),C=c.$dynamic(),y=D(e),_=g(C,{...e,limit:y+1}),[k,I]=await Promise.all([_.all(),$]),p=k,N=p.length>y;return{items:p.slice(0,y).map(d=>f(d)).filter(d=>d!==null),hasMore:N,total:I}}async getEntityById(e,i){const{rbacTeams:n,excludedTypes:r,excludedEntities:s}=i||{},o=F(r,s,"entities"),c=await this.#t.client.select(w("entities")).from(t).leftJoin(m,l(t.key,m.entityKey)).where(a(l(t.id,e),b(n,"entities_attributes"),o)).get();return c?f(c):null}async getEntityKeysAndVersionsBySourceFile(e){const i=await this.#t.client.selectDistinct({keyVersion:u`${t.key} || ':' || COALESCE(${t.version}, ${L})`.as("keyVersion")}).from(t).where(a(l(t.sourceFile,e),l(t.source,"file"),R(t.key))).all();return new Set(i.map(n=>n.keyVersion))}async getEntitiesCountByTypes(){return this.#t.client.select({type:t.type,count:h()}).from(t).where(a(l(t.isCurrent,!0),l(t.isDeleted,!1))).groupBy(t.type)}async getOutdatedEntities(e){const i=this.#t.client.select(E).from(t).$dynamic(),{whereCondition:n}=B(i,e),r=A(u`scorecards_status = 'OUTDATED'`,u`scorecards_status IS NULL`),s=n?a(n,r):r;return(await i.where(s).all()).map(c=>f(c)).filter(c=>c!==null)}async getEntitiesCount(e,i,n){let r;try{const s=await this.#t.client.select({count:h()}).from(t).where(l(t.source,e));if(r=Number(s[0]?.count??0),i?.length){const o=await this.#e(e,i);r+=i.length-o}return n!==void 0&&(r-=n),{total:r}}catch(s){throw v.error("Error getting entities count:",s),new Error(`Error getting entities count: ${s?.message}`)}}async#e(e,i){const n=u.join(i.map(o=>u`(${o.key}, ${o.version}, ${o.revision})`),u`, `),r=await this.#t.client.run(u`SELECT count(*) AS count FROM entities WHERE source = ${e} AND (key, version, revision) IN (VALUES ${n})`),s=O(r);return Number(s?.count??0)}}export{G as EntitiesReadRepository};

package/dist/server/plugins/catalog-entities/database/repositories/entities/entities-write-repository.d.ts

@@ -0,0 +1,27 @@
+import type { DatabaseClient } from '../../../../../providers/database/client';
+import type { EntityDtoSchema } from '../../../schemas/dto-schemas';
+import type { Filter } from '../../../../../providers/database/pagination/types';
+import type { CreateEntityParams } from '../types';
+import type { EntityReadModelSchema } from '../../../schemas/read-model-schemas';
+import type { ScorecardsStatus } from '../../../entities/types';
+export declare class EntitiesWriteRepository {
+    #private;
+    constructor(db: DatabaseClient, organizationId: string, projectId: string);
+    createEntity({ entity, source, fileHash, sourceFile, isRootEntity, isDeleted, rbacTeams, errorOnSkip, revision, }: CreateEntityParams): Promise<EntityReadModelSchema | null>;
+    updateEntity(incomingEntity: Partial<EntityDtoSchema>, entityToBeUpdated: EntityReadModelSchema): Promise<EntityReadModelSchema | null>;
+    setEntitiesAsOutdated(filter: Filter): Promise<void>;
+    softDeleteEntitiesWithRelations({ filter, revision, fileHash, }: {
+        filter: Filter;
+        revision: string;
+        fileHash: string;
+    }): Promise<void>;
+    deleteEntity(entityToBeRemoved: EntityReadModelSchema): Promise<string | null>;
+    /**
+     * Deletes entities based on a filter.
+     * If the entity is current or default version, we need to promote the different version as current and default.
+     */
+    deleteEntities(filter: Filter): Promise<boolean>;
+    updateEntityScorecardsStatus(entityId: string, status: ScorecardsStatus): Promise<boolean>;
+    updateEntityScorecardsStatusIfCalculating(entityId: string, status: Extract<ScorecardsStatus, 'UP_TO_DATE' | 'OUTDATED'>): Promise<boolean>;
+}
+//# sourceMappingURL=entities-write-repository.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/entities/entities-write-repository.js

@@ -0,0 +1 @@
+import{and as v,eq as c,isNull as R,or as z,sql as V}from"drizzle-orm";import{VERSION_NOT_SPECIFIED as F}from"@redocly/theme/core/constants";import{telemetryTraceStep as C}from"../../../../../telemetry/helpers/trace-step.js";import{sha1 as _}from"../../../../../utils/crypto/sha1.js";import{logger as d}from"../../../../../tools/notifiers/logger.js";import{envConfig as K}from"../../../../../config/env-config.js";import{entitiesTable as i}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{convertFilterToWhereCondition as O}from"../../../../../providers/database/pagination/filter.js";import{entitiesRelationsTable as a}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js";import{promiseMapLimit as m}from"../../../../../utils/async/promise-map-limit.js";import{RevisionRepository as H}from"../common/revision-repository.js";import{VersionRepository as $}from"../common/version-repository.js";import{EntityAttributesWriteRepository as P}from"../entityAttributes/entity-attributes-write-repository.js";import{createEntityDbRecord as W}from"../../mappers/create-entity-db-record.js";import{createEntityReadModel as D}from"../../mappers/create-entity-read-model.js";import{createEntityRelationDbRecordFromFileSchema as b}from"../../mappers/create-entity-relation-db-record-from-file-schema.js";import{createEntityRelationDbRecordFromDto as j}from"../../mappers/create-entity-relation-db-record-from-dto.js";import{EntitiesReadRepository as G}from"./entities-read-repository.js";import{RelationsReadRepository as M}from"../relations/relations-read-repository.js";import{RelationsWriteRepository as q}from"../relations/relations-write-repository.js";const E=15;class fe{#e;#t;#n;#o;#r;#i;#a;#u;#s;constructor(e,t,s){this.#e=e,this.#r=t,this.#i=s,this.#t=new H(e),this.#n=new $(e),this.#o=new P(e),this.#a=new G(e),this.#u=new M(e),this.#s=new q(e,t,s)}async createEntity({entity:e,source:t,fileHash:s,sourceFile:n,isRootEntity:r,isDeleted:o,rbacTeams:u,errorOnSkip:h=!1,revision:f}){return C("catalog_entities.remote_repository.create_entity",async()=>{const{relations:l=[],...p}=e,y=_(JSON.stringify(p)),g=e.version??F,A=f??new Date().toISOString(),L=await this.#t.shouldSkipRevisionCreation(e.key,g,y,r,o);if(Array.isArray(u)&&await this.#o.upsertEntityAttributes({entityKey:e.key,rbacTeams:u,organizationId:this.#r,projectId:this.#i}),L){if(h)throw new Error("Entity validation failed: entity already exists");return d.warn(`Entity ${e.key} already exists, skipping creation`),null}const{shouldSetNewCurrentRevision:w,hasCurrentRevision:x}=await this.#t.getCurrentRevisionInfo({key:e.key,version:g,revision:A}),k=W({entity:{...e,revision:A,hash:y,isCurrent:w,isDefaultVersion:w,isDeleted:o,version:g},organizationId:this.#r,projectId:this.#i,source:t,sourceFile:n??null,fileHash:s??null}),{key:S,...T}=k;if(w&&x&&(await this.#t.markAllRevisionsAsNotCurrent(S),await this.#n.markAllVersionsAsNotDefault(S)),K.isDevelopMode&&!K.REDOCLY_INTERNAL_DEV)return await this.#l(k,l);const N=await this.#e.client.insert(i).values(k).onConflictDoUpdate({target:[i.key,i.source,i.revision,i.version],set:T}).returning();return N.length?(l&&await this.#s.createEntityRelations(l.map(I=>({...I,sourceKey:e.key,targetKey:I.key}))),D(N[0])):null})}async updateEntity(e,t){return C("catalog_entities.remote_repository.update_entity",async()=>{try{d.info(`Updating entity ${t.key} in remote database`);const{shouldSetNewCurrentRevision:s,hasCurrentRevision:n}=await this.#t.getCurrentRevisionInfo({key:t.key,version:e.version??t.version??F,revision:t.revision});s&&n&&(await this.#t.markAllRevisionsAsNotCurrent(t.key),await this.#n.markAllVersionsAsNotDefault(t.key));const r=W({entity:{...t,...e,hash:_(JSON.stringify({...t,...e})),isCurrent:s,isDefaultVersion:s,createdAt:t.createdAt??void 0},organizationId:this.#r,projectId:this.#i,source:"remote",sourceFile:null,fileHash:null}),{key:o,source:u,scorecardsStatus:h,...f}=r,l=await this.#e.client.insert(i).values(r).onConflictDoUpdate({target:[i.key,i.source,i.revision,i.version],set:{...f,scorecardsStatus:V`CASE WHEN ${i.scorecardsStatus} = 'CALCULATING' THEN 'CANCELLED' ELSE 'OUTDATED' END`}}).returning();return l.length?D(l[0]):null}catch(s){return d.error("Error updating entity",s),null}})}async setEntitiesAsOutdated(e){try{const t=O(e);await this.#e.client.update(i).set({scorecardsStatus:"OUTDATED"}).where(t)}catch(t){d.error("Error updating entities as outdated",t)}}async#l(e,t){const{key:s,source:n,version:r,isDefaultVersion:o,...u}=e,l=await this.#e.client.select({id:i.id}).from(i).where(v(c(i.key,s),r?c(i.version,r):R(i.version))).limit(1).get()!=null?await this.#e.client.update(i).set(u).where(v(c(i.key,s),r?c(i.version,r):R(i.version))).returning():await this.#e.client.insert(i).values(e).onConflictDoUpdate({target:[i.key,i.source,i.revision,i.version],set:u}).returning(),p=t?.map(y=>{const g=b({relation:y,sourceFile:e.sourceFile??"",fileHash:e.fileHash??"",sourceKey:e.key,sourceVersion:e.version??null,sourceRevision:e.revision??null,organizationId:this.#r,projectId:this.#i});return this.#e.client.insert(a).values(g).onConflictDoUpdate({target:[a.sourceKey,a.targetKey,a.sourceVersion,a.targetVersion,a.sourceRevision,a.targetRevision,a.sourceToTargetRelation],set:g}).run()})??[];return await m(p,E,async y=>y),D(l[0])}async softDeleteEntitiesWithRelations({filter:e,revision:t,fileHash:s}){const r={op:"AND",conditions:[e,{field:"is_deleted",operator:"equal",value:!1}]};for(;;){const o=await this.#a.getEntities({paginationParams:{filter:r,limit:500}});if(o.items.length===0)break;const u=await this.#c({entities:o.items,revision:t,fileHash:s});await this.#d(u,t)}}async deleteEntity(e){return C("catalog_entities.remote_repository.delete_entity",async()=>{try{return await this.#s.deleteEntityRelationsOnEntityRemoval(e),await this.#e.client.delete(i).where(c(i.id,e.id)),await this.#t.ensureDefaultAndCurrentRevisionForKey(e.key),e.id}catch(t){return d.error("Error deleting entity",t),null}})}async deleteEntities(e){try{const t=O(e);if(!t)return!1;const s=await this.#e.client.delete(i).where(t).returning({key:i.key,source:i.source,isCurrent:i.isCurrent,isDefaultVersion:i.isDefaultVersion,version:i.version});if(s.length===0)return!0;const n=s.reduce((r,o)=>((o.isCurrent||o.isDefaultVersion)&&r.add(o.key),r),new Set);if(n.size===0)return!0;await m(Array.from(n),E,async r=>this.#t.ensureDefaultAndCurrentRevisionForKey(r));for(const r of s)await this.#e.client.delete(a).where(z(v(c(a.sourceKey,r.key),...r.version?[c(a.sourceVersion,r.version)]:[R(a.sourceVersion)]),v(c(a.targetKey,r.key),...r.version?[c(a.targetVersion,r.version)]:[R(a.targetVersion)])));return!0}catch(t){return d.error("Error deleting entities",t),!1}}async updateEntityScorecardsStatus(e,t){try{return(await this.#e.client.update(i).set({scorecardsStatus:t}).where(c(i.id,e)).returning()).length>0}catch(s){return d.error("Error updating entity scorecards status",s),!1}}async updateEntityScorecardsStatusIfCalculating(e,t){try{return(await this.#e.client.update(i).set({scorecardsStatus:t}).where(V`${i.id} = ${e} AND ${i.scorecardsStatus} = 'CALCULATING'`).returning()).length>0}catch(s){return d.error("Error updating entity scorecards status if calculating",s),!1}}async#c({entities:e,revision:t,fileHash:s}){try{return(await m(e,E,async r=>{const o={type:r.type,key:r.key,title:r.title,summary:r.summary??void 0,tags:r.tags??void 0,metadata:r.metadata??void 0,git:r.git??void 0,contact:r.contact??void 0,links:r.links??void 0,version:r.version??void 0};return this.createEntity({entity:o,sourceFile:r.sourceFile??"",fileHash:s,isDeleted:!0,errorOnSkip:!1,source:r.source,revision:t})})).filter(r=>r!==null)}catch(n){return d.error("Error soft deleting entities",n),[]}}async#d(e,t){try{if(e.length===0)return!0;const s=await m(e,E,async n=>(await this.#u.getRelationsForEntity(n.key,n.version,t)).map(o=>{if(!o)return null;const u=o.direction,h=o.sourceToTargetRelation,f=o.targetKey,l=u==="outgoing"?n.key:f,p=u==="outgoing"?f:n.key,y=u==="outgoing"?h:h.startsWith("reverse:")?h.slice(8):h;return!y||!l||!p?null:j({type:y,sourceKey:l,targetKey:p,sourceVersion:n.version,targetVersion:n.version,sourceRevision:t,targetRevision:t,isDeleted:!0},this.#r,this.#i)}).filter(o=>o!==null));return await m(s.flat(),E,async n=>this.#s.upsertEntityRelation(n)),!0}catch(s){return d.error("Error soft deleting entity relations",s),!1}}}export{fe as EntitiesWriteRepository};

package/dist/server/plugins/catalog-entities/database/repositories/entityAttributes/entity-attributes-write-repository.d.ts

@@ -0,0 +1,12 @@
+import type { DatabaseClient } from '../../../../../providers/database/client.js';
+export declare class EntityAttributesWriteRepository {
+    #private;
+    constructor(db: DatabaseClient);
+    upsertEntityAttributes({ entityKey, rbacTeams, organizationId, projectId, }: {
+        entityKey: string;
+        rbacTeams: string[];
+        organizationId: string;
+        projectId: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=entity-attributes-write-repository.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/entityAttributes/entity-attributes-write-repository.js

@@ -0,0 +1 @@
+import{entitiesAttributesTable as e}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-attributes-table.js";import{logger as n}from"../../../../../tools/notifiers/logger.js";import{createEntityAttributesDbRecord as a}from"../../mappers/create-entity-attributes-db-record.js";class p{#t;constructor(t){this.#t=t}async upsertEntityAttributes({entityKey:t,rbacTeams:r,organizationId:i,projectId:o}){try{await this.#t.client.insert(e).values(a({rbacTeams:r,entityKey:t,organizationId:i,projectId:o})).onConflictDoUpdate({target:[e.entityKey],set:{rbacTeams:JSON.stringify(r)}}).run()}catch(s){n.error("Error saving entity attributes",s)}}}export{p as EntityAttributesWriteRepository};