@redocly/realm 0.134.0-next.2 → 0.134.0-next.4

package/dist/server/persistence/kv/services/kv-service.js

@@ -1 +1 @@
-import{PLAN_GATES_DEFAULTS as u}from"../../../constants/entitlements.js";import{EntitlementsProvider as d}from"../../../entitlements/entitlements-provider.js";import{StorageLimitValidator as h}from"../../../providers/database/utils/storage-limit-validator.js";import{KvRepository as m}from"../repositories/kv-repository.js";import{encodeKvKey as g}from"../mappers/create-kv-db-record.js";import{kvKeyValidator as a,kvListOptionsValidator as f,kvListSelectorValidator as w,kvSetOptionsValidator as l}from"../schemas/kv-schemas.js";const E=100*1024*1024;class o{static#e;#t;#s;constructor(t){this.#t=t,this.#s=new h}static async#a(t){const e=await m.getInstance(t),s=new o(e);o.#e=s}static async getInstance(t){return o.#e||await o.#a(t),o.#e}async get(t){const e=a.parse(t);return await this.#t?.sync(),await this.#t?.get(e)??null}async getMany(t){if(t.length===0)return[];const e=t.map(s=>a.parse(s));return await this.#t?.sync(),await this.#t?.getMany(e)??[]}async list(t,e){const s=w.parse(t),r=f.parse(e??{});return await this.#t?.sync(),await this.#t?.list(s,r)??{items:[],total:0,cursor:null}}async set(t,e,s){const r=a.parse(t),n=l.parse(s??{});this.#r(e);const i=JSON.stringify(e);return this.#n(i),await this.#i(r,i),await this.#t?.set(r,e,n)??null}async delete(t){const e=a.parse(t);return this.#t?.delete(e)}async clearExpired(){return await this.#t?.clearExpired()}async transaction(t){if(!this.#t)throw new Error("Remote repository not available for transactions");return await this.#t.sync(),this.#t.transaction(async e=>t({get:async r=>{const n=a.parse(r);return e.get(n)},getMany:async r=>{const n=r.map(i=>a.parse(i));return e.getMany(n)},set:async(r,n,i)=>{const c=a.parse(r),p=l.parse(i??{});this.#r(n);const y=JSON.stringify(n);return this.#n(y),await this.#i(c,y),e.set(c,n,p)},delete:async r=>{const n=a.parse(r);return e.delete(n)}}))}#r(t){try{JSON.stringify(t)}catch(e){const s=e instanceof Error?e.message:"Unknown error";throw new Error(`Value is not JSON serializable: ${s}`)}}#n(t){const s=Buffer.byteLength(t,"utf8");if(s>1048576){const r=(s/1024).toFixed(2);throw new Error(`Value size (${r} KB) exceeds the maximum allowed size of 1 MB (1024 KB)`)}}async#i(t,e){if(!this.#t)return;const s=g(t),r=await this.#t.getTotalStoredEntryBytes(),n=Math.max(0,r-E),i=await this.#t.getStoredEntrySizeByEncodedKey(s),c=Buffer.byteLength(s,"utf8")+Buffer.byteLength(e,"utf8");this.#s.validate({storageLimitGb:this.#o(),currentTotalBytes:n,existingEntryBytes:i,incomingEntryBytes:c,errorMessagePrefix:"KV storage limit"})}#o(){const t=d.instance().entitlements?.kvStorageLimit;return typeof t=="number"&&t>0?t:u.pro.kvStorageLimit}}export{o as KvService};
+import{PLAN_GATES_DEFAULTS as g}from"../../../constants/entitlements.js";import{EntitlementsProvider as m}from"../../../entitlements/entitlements-provider.js";import{BaseService as S}from"../../../providers/database/base-service.js";import{InstanceCacheResolver as f}from"../../../providers/database/instance-cache-resolver.js";import{StorageLimitValidator as h}from"../../../providers/database/utils/storage-limit-validator.js";import{KvRepository as p}from"../repositories/kv-repository.js";import{encodeKvKey as E}from"../mappers/create-kv-db-record.js";import{kvKeyValidator as i,kvListOptionsValidator as B,kvListSelectorValidator as w,kvSetOptionsValidator as d}from"../schemas/kv-schemas.js";const k=100*1024*1024;class l extends S{static#n=new f(async t=>new l(await p.create(t),t));#t;constructor(t,e){super(e,{repository:t,createRepository:p.create}),this.#t=new h}static async getInstance(t){return l.#n.get(t)}async get(t){const e=i.parse(t);return this.runRead(r=>r.get(e))}async getMany(t){if(t.length===0)return[];const e=t.map(r=>i.parse(r));return this.runRead(r=>r.getMany(e))}async list(t,e){const r=w.parse(t),s=B.parse(e??{});return this.runRead(n=>n.list(r,s))}async set(t,e,r){const s=i.parse(t),n=d.parse(r??{});this.#e(e);const a=JSON.stringify(e);return this.#r(a),await this.#s(s,a),this.runWrite(o=>o.set(s,e,n))}async delete(t){const e=i.parse(t);await this.runWrite(r=>r.delete(e))}async clearExpired(){await this.runWrite(t=>t.clearExpired())}async transaction(t){return await this.syncRepositoryIfNeeded(),this.getRepository().transaction(async e=>t({get:async s=>{const n=i.parse(s);return e.get(n)},getMany:async s=>{const n=s.map(a=>i.parse(a));return e.getMany(n)},set:async(s,n,a)=>{const o=i.parse(s),c=d.parse(a??{});this.#e(n);const y=JSON.stringify(n);return this.#r(y),await this.#s(o,y,{skipSync:!0}),e.set(o,n,c)},delete:async s=>{const n=i.parse(s);return e.delete(n)}}))}#e(t){try{JSON.stringify(t)}catch(e){const r=e instanceof Error?e.message:"Unknown error";throw new Error(`Value is not JSON serializable: ${r}`)}}#r(t){const r=Buffer.byteLength(t,"utf8");if(r>1048576){const s=(r/1024).toFixed(2);throw new Error(`Value size (${s} KB) exceeds the maximum allowed size of 1 MB (1024 KB)`)}}async#s(t,e,r){const s=E(t),n=await this.runRead(async c=>{const y=await c.getTotalStoredEntryBytes(),u=await c.getStoredEntrySizeByEncodedKey(s);return{currentTotalStoredEntryBytes:y,existingEntryBytes:u}},{onRepositoryMissing:()=>null,skipSync:r?.skipSync??!1});if(!n)return;const a=Math.max(0,n.currentTotalStoredEntryBytes-k),o=Buffer.byteLength(s,"utf8")+Buffer.byteLength(e,"utf8");this.#t.validate({storageLimitGb:this.#a(),currentTotalBytes:a,existingEntryBytes:n.existingEntryBytes,incomingEntryBytes:o,errorMessagePrefix:"KV storage limit"})}#a(){const t=m.instance().entitlements?.kvStorageLimit;return typeof t=="number"&&t>0?t:g.pro.kvStorageLimit}}export{l as KvService};

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

@@ -8,16 +8,17 @@ import type { Filter } from '../../../providers/database/pagination/types.js';
 import type { ScorecardsStatus } from '../entities/types.js';
 import type { GetEntityByIdParams } from '../types/params.js';
 import type { BulkSyncResult } from './types.js';
+import { BaseService } from '../../../providers/database/base-service.js';
 import { type EntityDtoSchema, type EntityRelationDtoSchema } from '../schemas/dto-schemas.js';
 import { CatalogEntitiesRepository } from './repositories/catalog-entities-repository.js';
 import { type ListResponseResult } from '../../../web-server/utils/prepare-list-response.js';
-export declare class CatalogEntitiesService {
+export declare class CatalogEntitiesService extends BaseService<CatalogEntitiesRepository> {
     #private;
     constructor(catalogEntitiesRepository: CatalogEntitiesRepository, options?: ServiceInstanceOptions);
     static getInstance(options: ServiceInstanceOptions): Promise<CatalogEntitiesService>;
     sync(): Promise<void>;
     transaction<T>(...args: Parameters<TransactionsManager['transaction']>): Promise<T>;
-    getEntities({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
+    getEntities({ paginationParams, rbacTeams, excludedTypes, excludedEntities }: {
         paginationParams: PaginationParams;
         rbacTeams?: string[];
         excludedTypes?: string[];
@@ -32,13 +33,13 @@ export declare class CatalogEntitiesService {
     getCatalogFilters(params: CatalogFiltersParams): Promise<Record<string, import("./repositories/types.js").FilterOption[]>>;
     getEntityRelationById(id: string): Promise<EntityRelationReadModelSchema | null>;
     getEntitiesRelations(paginationParams?: PaginationParams): Promise<ListResponseResult<EntityRelationReadModelSchema>>;
-    getEntitiesWithRelations({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
+    getEntitiesWithRelations({ paginationParams, rbacTeams, excludedTypes, excludedEntities }: {
         paginationParams: PaginationParams;
         rbacTeams?: string[];
         excludedTypes?: string[];
         excludedEntities?: string[];
     }): Promise<BffCatalogEntityList>;
-    getEntityWithRelationsByKey({ entityKey, filter, rbacTeams, excludedTypes, excludedEntities, }: {
+    getEntityWithRelationsByKey({ entityKey, filter, rbacTeams, excludedTypes, excludedEntities }: {
         entityKey: string;
         filter?: {
             revision?: string | null;
@@ -48,7 +49,7 @@ export declare class CatalogEntitiesService {
         excludedTypes?: string[];
         excludedEntities?: string[];
     }): Promise<BffCatalogEntity | null>;
-    getRelatedEntities({ entityKey, paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
+    getRelatedEntities({ entityKey, paginationParams, rbacTeams, excludedTypes, excludedEntities }: {
         entityKey: string;
         paginationParams: PaginationParams;
         rbacTeams?: string[];
@@ -75,7 +76,7 @@ export declare class CatalogEntitiesService {
     createEntitiesRelations(entities: EntityRelationDtoSchema[]): Promise<BulkSyncResult<EntityRelationReadModelSchema>>;
     updateEntityRelation(incomingRelationData: Partial<EntityRelationDtoSchema>, relationToBeUpdated: EntityRelationReadModelSchema): Promise<EntityRelationReadModelSchema | null>;
     deleteEntityRelation(id: string): Promise<string | null>;
-    softDeleteEntitiesWithRelations({ filter, revision, fileHash, }: {
+    softDeleteEntitiesWithRelations({ filter, revision, fileHash }: {
         filter: Filter;
         revision: string;
         fileHash: string;

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

@@ -1 +1 @@
-import{promiseMapLimit as h}from"../../../utils/async/promise-map-limit.js";import{logger as g}from"../../../tools/notifiers/logger.js";import{envConfig as y}from"../../../config/env-config.js";import{HTTP_TRANSIENT_RETRY as l,describeTransientError as m,isTransientSqldError as w,withTransientErrorRetry as d}from"../../../providers/database/transient-sqld-error.js";import{CatalogEntitiesRepository as E}from"./repositories/catalog-entities-repository.js";import{prepareListResponse as u}from"../../../web-server/utils/prepare-list-response.js";import{ENTITY_RELATION_FROM_DATABASE as R}from"./mappers/field-transformations.js";import{hasOptionsChanged as W}from"../utils/has-options-changed.js";const p=15;class s{static#s;static#n;#i;#r;#a={};constructor(t,e){this.#i=t,this.#r=e?.databaseType==="local"}static async#c(t){const e=await E.getInstance(t),i=new s(e,t);return s.#s=i,s.#n=t,i}static async getInstance(t){const e={...t,removeExisting:t.removeExisting??!1};return s.#s&&!W(s.#n,e)?s.#s:s.#c(e)}async sync(){await this.#o()}async transaction(...t){return this.#i.transactionsManager.transaction(...t)}async getEntities({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n}){return this.#e(async r=>{const{items:a,total:o,hasMore:c}=await r.entitiesRead.getEntities({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n});return u({data:a,params:t,totalCount:o,hasMore:c})})}async getEntityById(t,e){return this.#e(async i=>await i.entitiesRead.getEntityById(t,e)??null)}async getEntityKeysAndVersionsBySourceFile(t){return this.#e(e=>e.entitiesRead.getEntityKeysAndVersionsBySourceFile(t))}async getEntitiesCountByTypes(){return this.#e(t=>t.entitiesRead.getEntitiesCountByTypes())}async getCatalogFilters(t){return this.#e(e=>e.filters.getCatalogFilters(t))}async getEntityRelationById(t){return this.#e(async e=>await e.relationsRead.getEntityRelationById(t)??null)}async getEntitiesRelations(t={}){return this.#e(async e=>{const{items:i,total:n,hasMore:r}=await e.relationsRead.getEntitiesRelations(t);return u({data:i,params:t,totalCount:n,nameTransformationsFromDatabase:R,hasMore:r})})}async getEntitiesWithRelations({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n}){return this.#e(async r=>{const{items:a,total:o,hasMore:c}=await r.bffEntitiesRead.getEntitiesWithRelations({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n});return u({data:a,params:t,totalCount:o,hasMore:c})})}async getEntityWithRelationsByKey({entityKey:t,filter:e,rbacTeams:i,excludedTypes:n,excludedEntities:r}){return this.#e(a=>a.bffEntitiesRead.getEntityWithRelationsByKey({entityKey:t,filter:e,rbacTeams:i,excludedTypes:n,excludedEntities:r}))}async getRelatedEntities({entityKey:t,paginationParams:e,rbacTeams:i,excludedTypes:n,excludedEntities:r}){return this.#e(async a=>{const{items:o,total:c,hasMore:f}=await a.relationsRead.getRelatedEntities({key:t,paginationParams:e,rbacTeams:i,excludedTypes:n,excludedEntities:r});return u({data:o,params:e,totalCount:c,nameTransformationsFromDatabase:R,hasMore:f})})}async listEntityRevisions(t,e){return this.#e(i=>i.revisions.listEntityRevisions(t,e))}async getOutdatedEntities(t){return this.#e(e=>e.entitiesRead.getOutdatedEntities(t))}async getEntitiesCount(t,e,i){return this.#e(n=>n.entitiesRead.getEntitiesCount(t,e,i))}async createEntity(t){if(y.isDevelopMode&&t.source==="remote")throw new Error("API based entity creation is not supported in the develop mode");return t.isRootEntity&&t.sourceFile&&(this.#a[t.sourceFile]={key:t.entity.key,version:t.entity.version??void 0}),this.#t(e=>e.entitiesWrite.createEntity(t))}async createEntities(t,e){if(y.isDevelopMode&&e==="remote")throw new Error("API based entity creation is not supported in the develop mode");return await h(t,p,async i=>this.#t(n=>n.entitiesWrite.createEntity({entity:i,source:e})).then(n=>({status:"ok",resource:n})).catch(n=>({key:i.key,status:"error",error:n})))}getEntitySources(){return this.#a}async createEntityRelations(t){await this.#t(e=>e.relationsWrite.createEntityRelations(t))}async updateEntity(t,e){if(y.isDevelopMode&&e.source==="remote")throw new Error("Entity update is not supported in the develop mode");return this.#t(i=>i.transactionsManager.transaction(()=>i.entitiesWrite.updateEntity(t,e)))}async deleteEntity(t){if(y.isDevelopMode&&t.source==="remote")throw new Error("Entity deletion is not supported in the develop mode");return this.#t(e=>e.entitiesWrite.deleteEntity(t))}async deleteEntities(t){await this.#t(async e=>{await e.entitiesWrite.deleteEntities(t)})}async createEntityRelation(t){return this.#t(e=>e.relationsWrite.createEntityRelation(t))}async createEntitiesRelations(t){return await h(t,p,async e=>this.#t(i=>i.relationsWrite.createEntityRelation(e)).then(i=>({status:"ok",resource:i})).catch(i=>({key:e.sourceKey,status:"error",error:i})))}async updateEntityRelation(t,e){const i={...e,...t,type:t.type??e.type};return this.#t(n=>n.relationsWrite.createEntityRelation(i))}async deleteEntityRelation(t){return this.#t(e=>e.relationsWrite.deleteEntityRelation(t))}async softDeleteEntitiesWithRelations({filter:t,revision:e,fileHash:i}){return this.#t(n=>n.entitiesWrite.softDeleteEntitiesWithRelations({filter:t,revision:e,fileHash:i}))}async updateEntityScorecardsStatus(t,e){return this.#t(i=>i.entitiesWrite.updateEntityScorecardsStatus(t,e))}async updateEntityScorecardsStatusIfCalculating(t,e){return this.#t(i=>i.entitiesWrite.updateEntityScorecardsStatusIfCalculating(t,e))}async setEntitiesAsOutdated(t){await this.#t(async e=>{await e.entitiesWrite.setEntitiesAsOutdated(t)})}async#o(){if(this.#r)return;const t=this.#i;await d(()=>t.sync(),l)}async#e(t){return await this.#o(),d(()=>t(this.#i),l)}async#t(t){return this.#r?t(this.#i):d(async()=>{try{return await t(this.#i)}catch(e){throw await this.#y(e),e}},l)}async#y(t){if(!(!w(t)||!s.#n))try{this.#i=await E.recreateInstance(s.#n)}catch(e){g.warn(`Reconnect attempt failed, letting original error propagate: ${m(e)}`)}}}export{s as CatalogEntitiesService};
+import{promiseMapLimit as d}from"../../../utils/async/promise-map-limit.js";import{envConfig as u}from"../../../config/env-config.js";import{BaseService as p}from"../../../providers/database/base-service.js";import{InstanceCacheResolver as W}from"../../../providers/database/instance-cache-resolver.js";import{CatalogEntitiesRepository as l}from"./repositories/catalog-entities-repository.js";import{prepareListResponse as y}from"../../../web-server/utils/prepare-list-response.js";import{ENTITY_RELATION_FROM_DATABASE as E}from"./mappers/field-transformations.js";const R=15;class c extends p{static#e=new W(async t=>new c(await l.create(t),t));#t={};constructor(t,e){super(e,{repository:t,createRepository:l.create})}static async getInstance(t){return c.#e.get(t)}async sync(){await this.syncRepositoryIfNeeded()}async transaction(...t){return this.getRepository().transactionsManager.transaction(...t)}async getEntities({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n}){return this.runRead(async s=>{const{items:r,total:a,hasMore:o}=await s.entitiesRead.getEntities({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n});return y({data:r,params:t,totalCount:a,hasMore:o})})}async getEntityById(t,e){return this.runRead(async i=>await i.entitiesRead.getEntityById(t,e)??null)}async getEntityKeysAndVersionsBySourceFile(t){return this.runRead(e=>e.entitiesRead.getEntityKeysAndVersionsBySourceFile(t))}async getEntitiesCountByTypes(){return this.runRead(t=>t.entitiesRead.getEntitiesCountByTypes())}async getCatalogFilters(t){return this.runRead(e=>e.filters.getCatalogFilters(t))}async getEntityRelationById(t){return this.runRead(async e=>await e.relationsRead.getEntityRelationById(t)??null)}async getEntitiesRelations(t={}){return this.runRead(async e=>{const{items:i,total:n,hasMore:s}=await e.relationsRead.getEntitiesRelations(t);return y({data:i,params:t,totalCount:n,nameTransformationsFromDatabase:E,hasMore:s})})}async getEntitiesWithRelations({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n}){return this.runRead(async s=>{const{items:r,total:a,hasMore:o}=await s.bffEntitiesRead.getEntitiesWithRelations({paginationParams:t,rbacTeams:e,excludedTypes:i,excludedEntities:n});return y({data:r,params:t,totalCount:a,hasMore:o})})}async getEntityWithRelationsByKey({entityKey:t,filter:e,rbacTeams:i,excludedTypes:n,excludedEntities:s}){return this.runRead(r=>r.bffEntitiesRead.getEntityWithRelationsByKey({entityKey:t,filter:e,rbacTeams:i,excludedTypes:n,excludedEntities:s}))}async getRelatedEntities({entityKey:t,paginationParams:e,rbacTeams:i,excludedTypes:n,excludedEntities:s}){return this.runRead(async r=>{const{items:a,total:o,hasMore:h}=await r.relationsRead.getRelatedEntities({key:t,paginationParams:e,rbacTeams:i,excludedTypes:n,excludedEntities:s});return y({data:a,params:e,totalCount:o,nameTransformationsFromDatabase:E,hasMore:h})})}async listEntityRevisions(t,e){return this.runRead(i=>i.revisions.listEntityRevisions(t,e))}async getOutdatedEntities(t){return this.runRead(e=>e.entitiesRead.getOutdatedEntities(t))}async getEntitiesCount(t,e,i){return this.runRead(n=>n.entitiesRead.getEntitiesCount(t,e,i))}async createEntity(t){if(u.isDevelopMode&&t.source==="remote")throw new Error("API based entity creation is not supported in the develop mode");return t.isRootEntity&&t.sourceFile&&(this.#t[t.sourceFile]={key:t.entity.key,version:t.entity.version??void 0}),this.runWrite(e=>e.entitiesWrite.createEntity(t))}async createEntities(t,e){if(u.isDevelopMode&&e==="remote")throw new Error("API based entity creation is not supported in the develop mode");return await d(t,R,async i=>this.runWrite(n=>n.entitiesWrite.createEntity({entity:i,source:e})).then(n=>({status:"ok",resource:n})).catch(n=>({key:i.key,status:"error",error:n})))}getEntitySources(){return this.#t}async createEntityRelations(t){await this.runWrite(e=>e.relationsWrite.createEntityRelations(t))}async updateEntity(t,e){if(u.isDevelopMode&&e.source==="remote")throw new Error("Entity update is not supported in the develop mode");return this.runWrite(i=>i.transactionsManager.transaction(()=>i.entitiesWrite.updateEntity(t,e)))}async deleteEntity(t){if(u.isDevelopMode&&t.source==="remote")throw new Error("Entity deletion is not supported in the develop mode");return this.runWrite(e=>e.entitiesWrite.deleteEntity(t))}async deleteEntities(t){await this.runWrite(async e=>{await e.entitiesWrite.deleteEntities(t)})}async createEntityRelation(t){return this.runWrite(e=>e.relationsWrite.createEntityRelation(t))}async createEntitiesRelations(t){return await d(t,R,async e=>this.runWrite(i=>i.relationsWrite.createEntityRelation(e)).then(i=>({status:"ok",resource:i})).catch(i=>({key:e.sourceKey,status:"error",error:i})))}async updateEntityRelation(t,e){const i={...e,...t,type:t.type??e.type};return this.runWrite(n=>n.relationsWrite.createEntityRelation(i))}async deleteEntityRelation(t){return this.runWrite(e=>e.relationsWrite.deleteEntityRelation(t))}async softDeleteEntitiesWithRelations({filter:t,revision:e,fileHash:i}){return this.runWrite(n=>n.entitiesWrite.softDeleteEntitiesWithRelations({filter:t,revision:e,fileHash:i}))}async updateEntityScorecardsStatus(t,e){return this.runWrite(i=>i.entitiesWrite.updateEntityScorecardsStatus(t,e))}async updateEntityScorecardsStatusIfCalculating(t,e){return this.runWrite(i=>i.entitiesWrite.updateEntityScorecardsStatusIfCalculating(t,e))}async setEntitiesAsOutdated(t){await this.runWrite(async e=>{await e.entitiesWrite.setEntitiesAsOutdated(t)})}}export{c as CatalogEntitiesService};

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

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

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

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

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

@@ -10,6 +10,6 @@ type CreateEntityRelationDbRecordFromFileSchemaParams = {
     organizationId: string;
     projectId: string;
 };
-export declare function createEntityRelationDbRecordFromFileSchema({ relation, sourceFile, fileHash, sourceKey, sourceVersion, sourceRevision, organizationId, projectId, }: CreateEntityRelationDbRecordFromFileSchemaParams): DatabaseEntityRelationDto;
+export declare function createEntityRelationDbRecordFromFileSchema({ relation, sourceFile, fileHash, sourceKey, sourceVersion, sourceRevision, organizationId, projectId }: CreateEntityRelationDbRecordFromFileSchemaParams): DatabaseEntityRelationDto;
 export {};
 //# sourceMappingURL=create-entity-relation-db-record-from-file-schema.d.ts.map

package/dist/server/plugins/catalog-entities/database/mappers/field-transformations.d.ts

@@ -1,7 +1,7 @@
 export declare const ENTITY_RELATION_TO_DATABASE: {
-    readonly relation_type: "source_to_target_relation";
+    readonly relation_type: 'source_to_target_relation';
 };
 export declare const ENTITY_RELATION_FROM_DATABASE: {
-    readonly source_to_target_relation: "relationType";
+    readonly source_to_target_relation: 'relationType';
 };
 //# sourceMappingURL=field-transformations.d.ts.map

package/dist/server/plugins/catalog-entities/database/remote-publish-lock-service.d.ts

@@ -3,17 +3,17 @@ export declare const INTERNAL_CATALOG_PUBLISH_CACHE_NAMESPACE = "catalog-publish
 export declare const INTERNAL_CATALOG_PUBLISH_KEY_PREFIX = "catalog-entities::publisher";
 export declare class RemotePublishLockService {
     #private;
-    static getInternalCacheValue({ remoteConnection, key, }: {
+    static getInternalCacheValue({ remoteConnection, key }: {
         remoteConnection: DatabaseConnection;
         key: string;
     }): Promise<string | null>;
-    static upsertInternalCacheValue({ remoteConnection, key, value, ttl, }: {
+    static upsertInternalCacheValue({ remoteConnection, key, value, ttl }: {
         remoteConnection: DatabaseConnection;
         key: string;
         value: string;
         ttl?: number | null;
     }): Promise<void>;
-    static runUnderRemotePublishLock<T>({ runId, remoteConnection, run, }: {
+    static runUnderRemotePublishLock<T>({ runId, remoteConnection, run }: {
         runId: string;
         remoteConnection: DatabaseConnection;
         run: () => Promise<T>;

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

@@ -5,13 +5,13 @@ import type { ListResult } from '../types.js';
 export declare class BffEntitiesReadRepository {
     #private;
     constructor(db: DatabaseClient);
-    getEntitiesWithRelations({ paginationParams, rbacTeams, excludedEntities, excludedTypes, }: {
+    getEntitiesWithRelations({ paginationParams, rbacTeams, excludedEntities, excludedTypes }: {
         paginationParams: PaginationParams;
         rbacTeams?: string[];
         excludedEntities?: string[];
         excludedTypes?: string[];
     }): Promise<ListResult<BffCatalogEntity>>;
-    getEntityWithRelationsByKey({ entityKey, filter, rbacTeams, excludedTypes, excludedEntities, }: {
+    getEntityWithRelationsByKey({ entityKey, filter, rbacTeams, excludedTypes, excludedEntities }: {
         entityKey: string;
         filter?: {
             revision?: string | null;

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

@@ -8,7 +8,6 @@ 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;
@@ -19,8 +18,6 @@ export declare class CatalogEntitiesRepository extends BaseRepository {
     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>;
+    static create(options: RepositoryInstanceOptions): Promise<CatalogEntitiesRepository>;
 }
 //# sourceMappingURL=catalog-entities-repository.d.ts.map

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

@@ -1 +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.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.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};
+import{logger as o}from"../../../../tools/notifiers/logger.js";import{telemetryTraceStep as i}from"../../../../telemetry/helpers/trace-step.js";import{BaseRepository as a}from"../../../../providers/database/base-repository.js";import{createDatabaseRepositoryInstance as n}from"../../../../providers/database/instance-cache-resolver.js";import{RelationsReadRepository as c}from"./relations/relations-read-repository.js";import{RevisionRepository as p}from"./common/revision-repository.js";import{BffEntitiesReadRepository as l}from"./bffEntities/bff-entities-read-repository.js";import{EntitiesReadRepository as m}from"./entities/entities-read-repository.js";import{EntitiesWriteRepository as y}from"./entities/entities-write-repository.js";import{RelationsWriteRepository as R}from"./relations/relations-write-repository.js";import{FiltersRepository as f}from"./common/filters-repository.js";class r extends a{entitiesRead;entitiesWrite;relationsRead;relationsWrite;bffEntitiesRead;filters;revisions;get transactionsManager(){return this.databaseClient.transactionsManager}constructor(t){super(t),this.revisions=new p(t.client),this.bffEntitiesRead=new l(t.client),this.relationsRead=new c(t.client),this.entitiesRead=new m(t.client),this.entitiesWrite=new y(t.client,this.organizationId,this.projectId),this.relationsWrite=new R(t.client,this.organizationId,this.projectId),this.filters=new f(t.client)}async sync(){return i("catalog_entities.repository.sync",async()=>{await this.databaseClient.sync()})}static async create(t){return await i("catalog_entities.repository.get_instance",async s=>{try{return await n(t,"catalog entities",r)}catch(e){throw o.error("Error creating db connection for catalog entities repository",e),s?.error(e),e}})}}export{r as CatalogEntitiesRepository};

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

@@ -3,6 +3,6 @@ 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[]>>;
+    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/revision-repository.d.ts

@@ -3,7 +3,7 @@ import type { EntityRevisionSummary } from '../../../schemas/read-model-schemas.
 export declare class RevisionRepository {
     #private;
     constructor(db: DatabaseClient);
-    getCurrentRevisionInfo({ key, version, revision, }: {
+    getCurrentRevisionInfo({ key, version, revision }: {
         key: string;
         version: string | null;
         revision: string | null;

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

@@ -7,7 +7,7 @@ import type { GetEntityByIdParams } from '../../../types/params';
 export declare class EntitiesReadRepository {
     #private;
     constructor(db: DatabaseClient);
-    getEntities({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
+    getEntities({ paginationParams, rbacTeams, excludedTypes, excludedEntities }: {
         paginationParams: PaginationParams;
         rbacTeams?: string[];
         excludedTypes?: string[];

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

@@ -1 +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};
+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 b}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{createEntityReadModel as f}from"../../mappers/create-entity-read-model.js";import{createEntityFieldsForSelect as w,FIELDS_TO_SELECT_FOR_ENTITY as p}from"../utils.js";import{buildRbacFilter as g}from"../utils/build-rbac-filter.js";import{buildEntitiesExclusionFilter as F}from"../utils/build-entities-exclusion-filter.js";class Y{#t;constructor(e){this.#t=e}async getEntities({paginationParams:e,rbacTeams:i,excludedTypes:n,excludedEntities:o}){const s=F(n,o,"entities"),r=this.#t.client.select(w("entities")).from(t).leftJoin(m,l(t.key,m.entityKey)).where(a(g(i,"entities_attributes"),s)),c=this.#t.client.select(p).from(r.as("combined_entities")),S=this.#t.client.select(p).from(r.as("combined_entities")).$dynamic(),T=b(S,{...e,limit:void 0,skip:void 0,after:void 0,before:void 0}),C=this.#t.client.$count(T),_=c.$dynamic(),y=D(e),$=b(_,{...e,limit:y+1}),[k,I]=await Promise.all([$.all(),C]),E=k,N=E.length>y;return{items:E.slice(0,y).map(d=>f(d)).filter(d=>d!==null),hasMore:N,total:I}}async getEntityById(e,i){const{rbacTeams:n,excludedTypes:o,excludedEntities:s}=i||{},r=F(o,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),g(n,"entities_attributes"),r)).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(p).from(t).$dynamic(),{whereCondition:n}=B(i,e),o=A(u`scorecards_status = 'OUTDATED'`,u`scorecards_status IS NULL`),s=n?a(n,o):o;return(await i.where(s).all()).map(c=>f(c)).filter(c=>c!==null)}async getEntitiesCount(e,i,n){const o=await this.#t.client.select({count:h()}).from(t).where(l(t.source,e));let s=Number(o[0]?.count??0);if(i?.length){const r=await this.#e(e,i);s+=i.length-r}return n!==void 0&&(s-=n),{total:s}}async#e(e,i){const n=u.join(i.map(r=>u`(${r.key}, ${r.version}, ${r.revision})`),u`, `),o=await this.#t.client.run(u`SELECT count(*) AS count FROM entities WHERE source = ${e} AND (key, version, revision) IN (VALUES ${n})`),s=O(o);return Number(s?.count??0)}}export{Y as EntitiesReadRepository};

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

@@ -7,10 +7,10 @@ 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>;
+    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, }: {
+    softDeleteEntitiesWithRelations({ filter, revision, fileHash }: {
         filter: Filter;
         revision: string;
         fileHash: string;

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

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

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

@@ -2,7 +2,7 @@ import type { DatabaseClient } from '../../../../../providers/database/client.js
 export declare class EntityAttributesWriteRepository {
     #private;
     constructor(db: DatabaseClient);
-    upsertEntityAttributes({ entityKey, rbacTeams, organizationId, projectId, }: {
+    upsertEntityAttributes({ entityKey, rbacTeams, organizationId, projectId }: {
         entityKey: string;
         rbacTeams: string[];
         organizationId: string;

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

@@ -10,10 +10,10 @@ export declare class RelationsReadRepository {
         targetKey: string;
         targetRevision: string;
         sourceToTargetRelation: string;
-        direction: "outgoing" | "incoming";
+        direction: 'outgoing' | 'incoming';
         priority: number;
     }[]>;
-    getRelatedEntities({ key, paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
+    getRelatedEntities({ key, paginationParams, rbacTeams, excludedTypes, excludedEntities }: {
         key: string;
         paginationParams: PaginationParams;
         rbacTeams?: string[];

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

@@ -1,5 +1,5 @@
 export declare const createEntityFieldsForSelect: (tableAlias?: string, idAlias?: string) => {
-    id: import("drizzle-orm").SQL<unknown> | import("drizzle-orm").SQL.Aliased<unknown>;
+    id: import("drizzle-orm").SQL.Aliased<unknown> | import("drizzle-orm").SQL<unknown>;
     organizationId: import("drizzle-orm").SQL<unknown>;
     projectId: import("drizzle-orm").SQL<unknown>;
     key: import("drizzle-orm").SQL<unknown>;
@@ -25,7 +25,7 @@ export declare const createEntityFieldsForSelect: (tableAlias?: string, idAlias?
     scorecardsStatus: import("drizzle-orm").SQL<unknown>;
 };
 export declare const createEntityRelationFieldsForSelect: (tableAlias?: string, idAlias?: string) => {
-    id: import("drizzle-orm").SQL<unknown> | import("drizzle-orm").SQL.Aliased<unknown>;
+    id: import("drizzle-orm").SQL.Aliased<unknown> | import("drizzle-orm").SQL<unknown>;
     organizationId: import("drizzle-orm").SQL<unknown>;
     projectId: import("drizzle-orm").SQL<unknown>;
     sourceKey: import("drizzle-orm").SQL<unknown>;
@@ -91,7 +91,7 @@ export declare const createQualifiedEntityFieldsForSelectWithAliases: (tableAlia
     isDeleted: import("drizzle-orm").SQL.Aliased<unknown>;
 };
 export declare const FIELDS_TO_SELECT_FOR_ENTITY: {
-    id: import("drizzle-orm").SQL<unknown> | import("drizzle-orm").SQL.Aliased<unknown>;
+    id: import("drizzle-orm").SQL.Aliased<unknown> | import("drizzle-orm").SQL<unknown>;
     organizationId: import("drizzle-orm").SQL<unknown>;
     projectId: import("drizzle-orm").SQL<unknown>;
     key: import("drizzle-orm").SQL<unknown>;
@@ -117,7 +117,7 @@ export declare const FIELDS_TO_SELECT_FOR_ENTITY: {
     scorecardsStatus: import("drizzle-orm").SQL<unknown>;
 };
 export declare const FIELDS_TO_SELECT_FOR_ENTITY_RELATION: {
-    id: import("drizzle-orm").SQL<unknown> | import("drizzle-orm").SQL.Aliased<unknown>;
+    id: import("drizzle-orm").SQL.Aliased<unknown> | import("drizzle-orm").SQL<unknown>;
     organizationId: import("drizzle-orm").SQL<unknown>;
     projectId: import("drizzle-orm").SQL<unknown>;
     sourceKey: import("drizzle-orm").SQL<unknown>;

package/dist/server/plugins/catalog-entities/extensions/extractors/api-description/base.d.ts

@@ -7,7 +7,7 @@ import type { BaseApiEntitiesExtractorParams, SpecType } from '../../../types/ex
 import type { EntityDtoSchema } from '../../../schemas/dto-schemas.js';
 export declare abstract class BaseApiEntitiesExtractor<BundledApiDefinition extends Pick<FileInfo, 'realRelativePath' | 'relativePath' | 'isVirtual' | 'hash'>> implements BaseEntitiesExtractor {
     #private;
-    protected type: "api-description";
+    protected type: 'api-description';
     protected specType: SpecType;
     protected fileType: FileType;
     protected actions: AfterRoutesCreatedActions;
@@ -26,7 +26,7 @@ export declare abstract class BaseApiEntitiesExtractor<BundledApiDefinition exte
      * @param customKey - Optional custom key from x-redocly-catalog-key
      * @param extensionPattern - Optional regex to strip file extension (default: any extension)
      */
-    protected resolveEntityKey({ realRelativePath, customKey, extensionPattern, }: {
+    protected resolveEntityKey({ realRelativePath, customKey, extensionPattern }: {
         realRelativePath: string;
         customKey?: string | null;
         extensionPattern?: RegExp;

package/dist/server/plugins/catalog-entities/extensions/extractors/fs-entities-extractor.d.ts

@@ -4,7 +4,7 @@ import type { CatalogEntitiesService } from '../../database/catalog-entities-ser
 import type { EntitiesCatalogConfig } from '@redocly/config';
 export declare class FsEntitiesExtractor {
     #private;
-    constructor({ fileHashManager, context, catalogEntitiesService, catalogConfig, shouldCalculateEntities, }: {
+    constructor({ fileHashManager, context, catalogEntitiesService, catalogConfig, shouldCalculateEntities }: {
         fileHashManager: HashManager;
         context: LifecycleContext;
         catalogEntitiesService: CatalogEntitiesService;