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

package/dist/server/plugins/api-functions/index.js

@@ -1 +1 @@
-import{join as p}from"path";import{REDOCLY_ROUTE_RBAC as f}from"@redocly/config";import{removeTrailingSlash as l}from"../../../utils/url/remove-trailing-slash.js";import{removeLeadingSlash as d}from"../../../utils/url/remove-leading-slash.js";import{USER_DEFINED_API_FUNCTIONS_COUNTER_KEY as m}from"../../../server/store.js";import{parseRouteFsPathForHono as h}from"./helpers/parse-route-fs-path-for-hono.js";import{telemetryTraceStep as F}from"../../../cli/telemetry/helpers/trace-step.js";const g="api-functions";function A(t){return d(l(t))}function R(t){return`^${A(t)}`}function E(t){const i=t.map(R);return i.push(".*@api"),new RegExp(`(${i.join("|")})/.*.(ts|js)$`)}async function T(){return{id:"ApiFunctions",requiredEntitlements:["apiFunctions"],async processContent(t,i){await F("build.plugin.api_functions",async r=>{const s=await i.getConfig();r?.setAttribute("config",JSON.stringify(s.apiFunctions||{}));const a=E(s.apiFunctions?.folders||[]);let o=0;for(const e of i.fs.scan(a)){if(e.isVirtual)continue;const n=h(e.relativePath);if(!n)continue;const u=`${g}:${n.handler}`,c=p(t.contentDir,n.handler);t.createRequestHandler(u,c),t.addApiRoute({requestHandlerId:u,slug:n.path,fsPath:e.relativePath,httpMethod:n.method,[f]:{fsPath:e.relativePath,slug:n.path}}),o++}r?.setAttribute("definedApiFunctions",String(o)),t.setGlobalConfig({[m]:o})})}}}export{g as API_FUNCTIONS_REQUEST_HANDLER_ID,T as apiFunctionsPlugin};
+import{join as p}from"path";import{transformSync as l}from"esbuild";import{REDOCLY_ROUTE_RBAC as d}from"@redocly/config";import{removeTrailingSlash as m}from"../../../utils/url/remove-trailing-slash.js";import{removeLeadingSlash as g}from"../../../utils/url/remove-leading-slash.js";import{logger as h}from"../../tools/notifiers/logger.js";import{USER_DEFINED_API_FUNCTIONS_COUNTER_KEY as F}from"../../../server/store.js";import{parseRouteFsPathForHono as A}from"./helpers/parse-route-fs-path-for-hono.js";import{telemetryTraceStep as P}from"../../../cli/telemetry/helpers/trace-step.js";const u="api-functions";async function R(t,n){try{const e=await n.fs.read(t);return l(e,{loader:t.endsWith(".js")?"js":"ts"}),!0}catch(e){const r=e instanceof Error?e.message:String(e);return h.warn(`Skipping API function ${t} because it cannot be parsed: ${r}`),!1}}function E(t){return g(m(t))}function _(t){return`^${E(t)}`}function S(t){const n=t.map(_);return n.push(".*@api"),new RegExp(`(${n.join("|")})/.*.(ts|js)$`)}async function O(){return{id:"ApiFunctions",requiredEntitlements:["apiFunctions"],async processContent(t,n){await P("build.plugin.api_functions",async e=>{const r=await n.getConfig();e?.setAttribute("config",JSON.stringify(r.apiFunctions||{}));const c=S(r.apiFunctions?.folders||[]);let s=0;t.clearRequestHandlersByPrefix(`${u}:`);for(const o of n.fs.scan(c)){if(o.isVirtual)continue;const i=A(o.relativePath);if(!i)continue;const a=`${u}:${i.handler}`,f=p(t.contentDir,i.handler);await R(o.relativePath,n)&&(t.createRequestHandler(a,f),t.addApiRoute({requestHandlerId:a,slug:i.path,fsPath:o.relativePath,httpMethod:i.method,[d]:{fsPath:o.relativePath,slug:i.path}}),s++)}e?.setAttribute("definedApiFunctions",String(s)),t.setGlobalConfig({[F]:s})})}}}export{u as API_FUNCTIONS_REQUEST_HANDLER_ID,O as apiFunctionsPlugin};

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

@@ -0,0 +1,6 @@
+import type { PublishCatalogEntitiesParams } from './types';
+export declare class CatalogEntitiesPublisher {
+    #private;
+    static publishFromLocalToRemote(params: PublishCatalogEntitiesParams): Promise<boolean>;
+}
+//# sourceMappingURL=catalog-entities-publisher.d.ts.map

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

@@ -0,0 +1,12 @@
+import{and as h,eq as g,inArray as R,isNotNull as A,isNull as E,ne as k,or as I,sql as S}from"drizzle-orm";import{ulid as N}from"ulid";import{logger as F}from"../../../tools/notifiers/logger.js";import{DatabaseConnectionFactory as D}from"../../../providers/database/database-connection-factory.js";import{entitiesAttributesTable as m}from"../../../providers/database/databases/sqlite-db/schemas/entities-attributes-table.js";import{entitiesRelationsTable as u}from"../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js";import{entitiesTable as d}from"../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{BATCH_TRANSIENT_RETRY as $,withTransientErrorRetry as L}from"../../../providers/database/transient-sqld-error.js";import{envConfig as O}from"../../../config/env-config.js";import{ATTRIBUTES_UPSERT_SET as U,DEFAULT_CHUNK_SIZE as B,ENTITIES_UPSERT_SET as K,MAX_BATCH_PAYLOAD_BYTES as M,MAX_LOGGED_DB_ERROR_LENGTH as b,MIN_RETRYABLE_BATCH_SIZE as H,RELATIONS_UPSERT_SET as x}from"./consts.js";class c{static async publishFromLocalToRemote(e){if(O.isDevelopMode)return!1;const{baseDbDir:t,chunkSize:s=B,changedSourceFiles:o=[],removedSourceFiles:n=[]}=e,a=N(),[i,r]=await Promise.all([D.create({baseDbDir:t,databaseType:"local"}),D.create({baseDbDir:t,databaseType:"remote"})]);if(!i||!r)return F.warn("Skipping entities remote sync: local or remote connection is unavailable"),!1;const l="changedSourceFiles"in e||"removedSourceFiles"in e,p=Array.from(new Set([...o,...n]));if(l&&p.length===0)return!0;const y=l?o.length?o:"none":void 0;try{return await c.#i({runId:a,chunkSize:s,localConnection:i,remoteConnection:r,sourceFilesFilter:y}),await c.#c({runId:a,chunkSize:s,localConnection:i,remoteConnection:r,sourceFilesFilter:y}),await c.#a({chunkSize:s,localConnection:i,remoteConnection:r,sourceFilesFilter:y}),await c.#l({runId:a,remoteConnection:r,sourceFilesFilter:l?p:void 0}),!0}catch(f){const w=c.#o(f);throw F.error(`[CatalogEntitiesPublisher.publishFromLocalToRemote] Failed runId=${a}. ${w}`),new Error(`[CatalogEntitiesPublisher.publishFromLocalToRemote] Failed runId=${a}. ${w}`,{cause:f instanceof Error?f:void 0})}}static#i(e){const{runId:t,localConnection:s,remoteConnection:o,sourceFilesFilter:n,chunkSize:a}=e,i=c.#e(n);return c.#t({chunkSize:a,sourceFilesFilter:n,selectRows:(r,l)=>s.client.client.select().from(d).where(h(g(d.source,"file"),i?R(d.sourceFile,i):void 0)).limit(l).offset(r).all(),decorateRow:r=>({...r,lastSeenRunId:t}),runUpsert:async r=>{await o.client.client.insert(d).values(r).onConflictDoUpdate({target:[d.key,d.source,d.revision,d.version],set:K}).run()},describeSkippedRow:r=>`entity key=${String(r.key)}`})}static#c(e){const{runId:t,localConnection:s,remoteConnection:o,sourceFilesFilter:n,chunkSize:a}=e,i=c.#e(n);return c.#t({chunkSize:a,sourceFilesFilter:n,selectRows:(r,l)=>s.client.client.select().from(u).where(h(A(u.sourceFile),i?R(u.sourceFile,i):void 0)).limit(l).offset(r).all(),decorateRow:r=>({...r,lastSeenRunId:t}),runUpsert:async r=>{await o.client.client.insert(u).values(r).onConflictDoUpdate({target:[u.sourceKey,u.targetKey,u.sourceVersion,u.targetVersion,u.sourceRevision,u.targetRevision,u.sourceToTargetRelation],set:x}).run()},describeSkippedRow:r=>{const l=r;return`relation sourceKey=${String(l.sourceKey)} targetKey=${String(l.targetKey)}`}})}static#a(e){const{localConnection:t,remoteConnection:s,sourceFilesFilter:o,chunkSize:n}=e,a=c.#e(o);return c.#t({chunkSize:n,sourceFilesFilter:o,selectRows:(i,r)=>t.client.client.select().from(m).where(a?S`EXISTS (
+                  SELECT 1
+                  FROM entities e
+                  WHERE e.key = ${m.entityKey}
+                    AND e.source = 'file'
+                    AND e.source_file IN (${S.join(a.map(l=>S`${l}`),S`, `)})
+                )`:void 0).limit(r).offset(i).all(),runUpsert:async i=>{await s.client.client.insert(m).values(i).onConflictDoUpdate({target:[m.entityKey],set:U}).run()}})}static#e(e){return Array.isArray(e)&&e.length>0?e:void 0}static async#t({chunkSize:e,sourceFilesFilter:t,selectRows:s,decorateRow:o,runUpsert:n,describeSkippedRow:a}){if(t==="none")return{upserted:0,skipped:0};let i=0,r=0,l=0;for(;;){const p=await s(i,e);if(!p.length)return{upserted:r,skipped:l};const y=o?p.map(f=>o(f)):p;for(const f of c.#u(y,e,M)){const w=await c.#n({rows:f,runOperation:n,shouldSkipIsolatedRow:a?(v,T)=>c.#f(T)?(F.warn(`[CatalogEntitiesPublisher.publishFromLocalToRemote] Skipping ${a(v)} due to remote insert error: ${c.#o(T)}`),!0):!1:void 0});r+=w.upserted,l+=w.skipped}i+=e}}static async#l({runId:e,remoteConnection:t,sourceFilesFilter:s}){const o=t.client.client,n=s?.length?s:void 0,a=await c.#r(()=>o.delete(u).where(h(A(u.sourceFile),n?R(u.sourceFile,n):void 0,I(E(u.lastSeenRunId),k(u.lastSeenRunId,e)))).run()),i=await c.#r(()=>o.delete(d).where(h(g(d.source,"file"),n?R(d.sourceFile,n):void 0,I(E(d.lastSeenRunId),k(d.lastSeenRunId,e)))).run()),r=await c.#r(()=>o.delete(m).where(S`NOT EXISTS (
+                SELECT 1
+                FROM entities e
+                WHERE e.key = ${m.entityKey}
+                  AND COALESCE(e.is_deleted, 0) = 0
+              )`).run());return{staleEntitiesDeleted:i,staleRelationsDeleted:a,orphanAttributesDeleted:r}}static async#r(e){const t=await c.#s(e);return Number(t.rowsAffected??0)}static#u(e,t,s){const o=[];let n=[],a=0;for(const i of e){const r=c.#d(i);n.length>0&&(n.length>=t||a+r>s)&&(o.push(n),n=[],a=0),n.push(i),a+=r}return n.length>0&&o.push(n),o}static#d(e){try{return JSON.stringify(e).length}catch{return 0}}static async#n({rows:e,runOperation:t,shouldSkipIsolatedRow:s}){try{return await c.#s(()=>t(e)),{upserted:e.length,skipped:0}}catch(o){if(e.length<H){if(!s)throw o;if(await s(e[0],o))return{upserted:0,skipped:1};throw o}const n=Math.floor(e.length/2),a=await c.#n({rows:e.slice(0,n),runOperation:t,shouldSkipIsolatedRow:s}),i=await c.#n({rows:e.slice(n),runOperation:t,shouldSkipIsolatedRow:s});return{upserted:a.upserted+i.upserted,skipped:a.skipped+i.skipped}}}static#f(e){if(!(e instanceof Error))return!1;const t=e.message.toLowerCase();return t.includes("code: 11")||t.includes("too many sql variables")||t.includes("string or blob too big")||t.includes("statement too long")||t.includes("request body too large")||t.includes("payload too large")||t.includes("body too large")||t.includes("resource exhausted")}static#o(e){const s=(e instanceof Error?e.message:typeof e=="string"?e:JSON.stringify(e)).split(" params:")[0],n=c.#p(s).replace(/\s+/g," ").trim();return n.length>b?`${n.slice(0,b)}...`:n}static#p(e){const t="Failed query:",s=e.indexOf(t);if(s===-1)return e;const o=e.slice(0,s).trim();return o?`${o}. ${t} <omitted for brevity>`:`${t} <omitted for brevity>`}static#s(e){return L(e,$)}}export{c as CatalogEntitiesPublisher};

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

@@ -1,31 +1,22 @@
 import type { PaginationParams } from '../../../providers/database/pagination/schemas.js';
-import type { EntityReadModelSchema, EntityRelationReadModelSchema } from '../schemas/read-model-schemas.js';
-import type { CatalogFiltersParams } from './repositories/local/catalog-entities-local-read-repository.js';
-import type { BffCatalogEntity, BffCatalogEntityList, BffCatalogRelatedEntityList } from '@redocly/theme/core/types';
+import type { EntityReadModelSchema, EntitySource, EntityRelationReadModelSchema } from '../schemas/read-model-schemas.js';
+import type { CatalogFiltersParams, CreateEntityParams } from './repositories/types.js';
+import type { BffCatalogEntity, BffCatalogEntityList, BffCatalogRelatedEntityList, SidebarConnectedEntity } from '@redocly/theme/core/types';
 import type { ServiceInstanceOptions } from '../../../providers/database/types.js';
 import type { TransactionsManager } from '../../../providers/database/transactions-manager.js';
-import type { CreateEntityParams } from './repositories/local/catalog-entities-local-write-repository.js';
 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 { type EntityDtoSchema, type EntityRelationDtoSchema } from '../schemas/dto-schemas.js';
-import { CatalogEntitiesLocalRepository } from './repositories/local/catalog-entities-local-repository.js';
-import { CatalogEntitiesRemoteRepository } from './repositories/remote/catalog-entities-remote-repository.js';
+import { CatalogEntitiesRepository } from './repositories/catalog-entities-repository.js';
 import { type ListResponseResult } from '../../../web-server/utils/prepare-list-response.js';
-type BulkSyncResult<T> = Array<{
-    status: 'ok';
-    resource: T | null;
-} | {
-    key: string;
-    status: 'error';
-    error: string;
-}>;
 export declare class CatalogEntitiesService {
     #private;
-    constructor(localRepository: CatalogEntitiesLocalRepository, remoteRepository: CatalogEntitiesRemoteRepository | null);
+    constructor(catalogEntitiesRepository: CatalogEntitiesRepository, options?: ServiceInstanceOptions);
     static getInstance(options: ServiceInstanceOptions): Promise<CatalogEntitiesService>;
+    sync(): Promise<void>;
     transaction<T>(...args: Parameters<TransactionsManager['transaction']>): Promise<T>;
-    remoteTransaction<T>(operation: () => Promise<T>): Promise<T>;
     getEntities({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
         paginationParams: PaginationParams;
         rbacTeams?: string[];
@@ -38,48 +29,9 @@ export declare class CatalogEntitiesService {
         type: string;
         count: number;
     }[]>;
-    getCatalogFilters(params: CatalogFiltersParams): Promise<Record<string, import("./repositories/local/catalog-entities-local-read-repository.js").FilterOption[]>>;
-    createEntity(entity: EntityDtoSchema): Promise<EntityReadModelSchema | null>;
-    createEntities(entities: EntityDtoSchema[]): Promise<BulkSyncResult<EntityReadModelSchema>>;
-    getEntitySources(): Record<string, import("@redocly/theme").SidebarConnectedEntity>;
-    /**
-     * Use only internally, everything that is created via API should be created in the remote database.
-     * @param entity - The entity to create.
-     */
-    createEntityInLocalDatabase(createEntityParams: CreateEntityParams): Promise<import("./repositories/local/catalog-entities-local-write-repository.js").CreateEntityResult>;
-    /**
-     * Use only internally, everything that is created via API should be created in the remote database.
-     * @param entities - The entities to create.
-     */
-    createEntitiesInLocalDatabase(createEntitiesParams: CreateEntityParams[]): Promise<void>;
-    /**
-     * Use only internally, everything that is created via API should be created in the remote database.
-     * @param relation - The entity to create.
-     */
-    createEntityRelationInLocalDatabase(relation: EntityRelationDtoSchema): Promise<void>;
-    /**
-     * Use only internally, everything that is created via API should be created in the remote database.
-     * @param relations - The entity to create.
-     */
-    createEntityRelationsInLocalDatabase(relations: EntityRelationDtoSchema[]): Promise<void>;
-    updateEntity(incomingEntity: Partial<EntityDtoSchema>, entityToBeUpdated: EntityReadModelSchema): Promise<EntityReadModelSchema | null | undefined>;
-    deleteEntity(entityToBeRemoved: EntityReadModelSchema): Promise<string | null | undefined>;
-    /**
-     * Use only internally, everything that is created via API should be created in the remote database.
-     * @param filter - The conditions used to select which entities to delete.
-     */
-    deleteEntitiesInLocalDatabase(filter: Filter): Promise<void>;
+    getCatalogFilters(params: CatalogFiltersParams): Promise<Record<string, import("./repositories/types.js").FilterOption[]>>;
     getEntityRelationById(id: string): Promise<EntityRelationReadModelSchema | null>;
     getEntitiesRelations(paginationParams?: PaginationParams): Promise<ListResponseResult<EntityRelationReadModelSchema>>;
-    createEntityRelation(relation: EntityRelationDtoSchema): Promise<EntityRelationReadModelSchema | null | undefined>;
-    createEntitiesRelations(entities: EntityRelationDtoSchema[]): Promise<BulkSyncResult<EntityRelationReadModelSchema>>;
-    updateEntityRelation(incomingRelationData: Partial<EntityRelationDtoSchema>, relationToBeUpdated: EntityRelationReadModelSchema): Promise<EntityRelationReadModelSchema | null | undefined>;
-    deleteEntityRelation(id: string): Promise<string | null>;
-    /**
-     * Use only internally, everything that is created via API should be created in the remote database.
-     * @param filter - The conditions used to select which entity relations to delete.
-     */
-    deleteEntityRelationsInLocalDatabase(filter: Filter): Promise<void>;
     getEntitiesWithRelations({ paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
         paginationParams: PaginationParams;
         rbacTeams?: string[];
@@ -103,22 +55,33 @@ export declare class CatalogEntitiesService {
         excludedTypes?: string[];
         excludedEntities?: string[];
     }): Promise<BffCatalogRelatedEntityList>;
-    softDeleteEntitiesInLocalDatabase({ filter, revision, fileHash, }: {
+    listEntityRevisions(entityKey: string, version?: string | null): Promise<import("../schemas/read-model-schemas.js").EntityRevisionSummary[]>;
+    getOutdatedEntities(filter?: Filter): Promise<EntityReadModelSchema[]>;
+    getEntitiesCount(source: EntitySource, addedEntities?: EntityReadModelSchema[], entitiesRemovedCount?: number): Promise<{
+        total: number;
+    }>;
+    createEntity(createEntityParams: CreateEntityParams): Promise<EntityReadModelSchema | null>;
+    createEntities(entities: EntityDtoSchema[], source: EntitySource): Promise<BulkSyncResult<EntityReadModelSchema>>;
+    getEntitySources(): Record<string, SidebarConnectedEntity>;
+    /**
+     * Use only internally, everything that is created via API should be created in the remote database.
+     * @param relations - The entity to create.
+     */
+    createEntityRelations(relations: EntityRelationDtoSchema[]): Promise<void>;
+    updateEntity(incomingEntity: Partial<EntityDtoSchema>, entityToBeUpdated: EntityReadModelSchema): Promise<EntityReadModelSchema | null>;
+    deleteEntity(entityToBeRemoved: EntityReadModelSchema): Promise<string | null>;
+    deleteEntities(filter: Filter): Promise<void>;
+    createEntityRelation(relation: EntityRelationDtoSchema): Promise<EntityRelationReadModelSchema | null>;
+    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, }: {
         filter: Filter;
         revision: string;
         fileHash: string;
     }): Promise<void>;
-    listEntityRevisions(entityKey: string, version?: string | null): Promise<import("../schemas/read-model-schemas.js").EntityRevisionSummary[]>;
     updateEntityScorecardsStatus(entityId: string, status: ScorecardsStatus): Promise<boolean>;
     updateEntityScorecardsStatusIfCalculating(entityId: string, status: Extract<ScorecardsStatus, 'UP_TO_DATE' | 'OUTDATED'>): Promise<boolean>;
-    getOutdatedEntities(filter?: Filter): Promise<EntityReadModelSchema[]>;
     setEntitiesAsOutdated(filter: Filter): Promise<void>;
-    getEntitiesCount(source: 'file' | 'remote', addedEntities?: EntityReadModelSchema[], entitiesRemovedCount?: number): Promise<{
-        total: number;
-    }>;
-    getDuplicatedEntitiesCount(addedEntities?: EntityReadModelSchema[], removedEntities?: EntityReadModelSchema[]): Promise<{
-        total: number;
-    }>;
 }
-export {};
 //# sourceMappingURL=catalog-entities-service.d.ts.map

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

@@ -1 +1 @@
-import{promiseMapLimit as u}from"../../../utils/async/promise-map-limit.js";import{logger as y}from"../../../tools/notifiers/logger.js";import{envConfig as r}from"../../../config/env-config.js";import{CatalogEntitiesLocalRepository as w}from"./repositories/local/catalog-entities-local-repository.js";import{CatalogEntitiesRemoteRepository as p}from"./repositories/remote/catalog-entities-remote-repository.js";import{prepareListResponse as l}from"../../../web-server/utils/prepare-list-response.js";import{ENTITY_RELATION_FROM_DATABASE as h}from"./mappers/field-transformations.js";import{hasOptionsChanged as m}from"../utils/has-options-changed.js";const d=15;class n{static#a;static#i;#t;#e;constructor(t,e){this.#t=t,this.#e=e}static async#n(t){const[e,a]=await Promise.all([w.getInstance(t),t.runOnlyLocalDatabase?null:p.getInstance(t)]),i=new n(e,a);a&&(r.isDevelopMode&&y.info("Attaching remote database to local database"),await i.#t.attachDatabase(a.path)),n.#a=i,n.#i=t}static async getInstance(t){return t.runOnlyLocalDatabase===void 0&&(t.runOnlyLocalDatabase=r.isDevelopMode),t.removeExisting===void 0&&(t.removeExisting=!1),(!n.#a||m(n.#i,t))&&await n.#n(t),n.#a}async transaction(...t){return this.#t.transactionsManager.transaction(...t)}async remoteTransaction(t){const e=this.#e;if(!e)throw new Error("Remote repository is not available");return e.transactionsManager.transaction(t)}async getEntities({paginationParams:t,rbacTeams:e,excludedTypes:a,excludedEntities:i}){await this.#e?.sync();const{items:s,total:o,hasMore:c}=await this.#t.getEntities({paginationParams:t,rbacTeams:e,excludedTypes:a,excludedEntities:i});return l({data:s,params:t,totalCount:o,hasMore:c})}async getEntityById(t,e){return await this.#e?.sync(),await this.#t.getEntityById(t,e)}async getEntityKeysAndVersionsBySourceFile(t){return await this.#e?.sync(),this.#t.getEntityKeysAndVersionsBySourceFile(t)}async getEntitiesCountByTypes(){return await this.#e?.sync(),this.#t.getEntitiesCountByTypes()}async getCatalogFilters(t){return await this.#e?.sync(),this.#t.getCatalogFilters(t)}async createEntity(t){if(r.isDevelopMode)throw new Error("Entity creation is not supported in the develop mode");return this.#e?this.#e.createEntity(t):(y.warn("No remote database found"),null)}async createEntities(t){if(r.isDevelopMode)throw new Error("Entity creation is not supported in the develop mode");const e=this.#e;return e?await u(t,d,async a=>e.createEntity(a).then(i=>({status:"ok",resource:i})).catch(i=>({key:a.key,status:"error",error:i}))):(y.warn("No remote database found"),[])}getEntitySources(){return this.#t.getEntitySources()}async createEntityInLocalDatabase(t){return this.#t.createEntity(t)}async createEntitiesInLocalDatabase(t){await this.#t.createEntities(t)}async createEntityRelationInLocalDatabase(t){await this.#t.createEntityRelation(t)}async createEntityRelationsInLocalDatabase(t){await this.#t.createEntityRelations(t)}async updateEntity(t,e){if(r.isDevelopMode)throw new Error("Entity update is not supported in the develop mode");return await this.#e?.updateEntity(t,e)}async deleteEntity(t){if(r.isDevelopMode)throw new Error("Entity deletion is not supported in the develop mode");return await this.#e?.deleteEntity(t)}async deleteEntitiesInLocalDatabase(t){await this.#t.deleteEntities(t)}async getEntityRelationById(t){return await this.#e?.sync(),await this.#t.getEntityRelationById(t)}async getEntitiesRelations(t={}){await this.#e?.sync();const{items:e,total:a,hasMore:i}=await this.#t.getEntitiesRelations(t);return l({data:e,params:t,totalCount:a,nameTransformationsFromDatabase:h,hasMore:i})}async createEntityRelation(t){return this.#e?.createEntityRelation(t)}async createEntitiesRelations(t){const e=this.#e;return e?await u(t,d,async a=>e.createEntityRelation(a).then(i=>({status:"ok",resource:i})).catch(i=>({key:a.sourceKey,status:"error",error:i}))):(y.warn("No remote database found"),[])}async updateEntityRelation(t,e){const a={...e,...t,type:t.type??e.type};return this.#e?.createEntityRelation(a)}async deleteEntityRelation(t){let e=await this.#e?.deleteEntityRelation(t);return e||(e=await this.#t.deleteEntityRelation(t)),e}async deleteEntityRelationsInLocalDatabase(t){await this.#t.deleteEntityRelations(t)}async getEntitiesWithRelations({paginationParams:t,rbacTeams:e,excludedTypes:a,excludedEntities:i}){await this.#e?.sync();const{items:s,total:o,hasMore:c}=await this.#t.getEntitiesWithRelations({paginationParams:t,rbacTeams:e,excludedTypes:a,excludedEntities:i});return l({data:s,params:t,totalCount:o,hasMore:c})}async getEntityWithRelationsByKey({entityKey:t,filter:e,rbacTeams:a,excludedTypes:i,excludedEntities:s}){return this.#t.getEntityWithRelationsByKey({entityKey:t,filter:e,rbacTeams:a,excludedTypes:i,excludedEntities:s})}async getRelatedEntities({entityKey:t,paginationParams:e,rbacTeams:a,excludedTypes:i,excludedEntities:s}){await this.#e?.sync();const{items:o,total:c,hasMore:E}=await this.#t.getRelatedEntities({key:t,paginationParams:e,rbacTeams:a,excludedTypes:i,excludedEntities:s});return l({data:o,params:e,totalCount:c,nameTransformationsFromDatabase:h,hasMore:E})}async softDeleteEntitiesInLocalDatabase({filter:t,revision:e,fileHash:a}){await this.#t.softDeleteEntities({filter:t,revision:e,fileHash:a})}async listEntityRevisions(t,e){return await this.#e?.sync(),this.#t.listEntityRevisions(t,e)}async updateEntityScorecardsStatus(t,e){return await this.#e?.sync(),this.#t.updateEntityScorecardsStatus(t,e)}async updateEntityScorecardsStatusIfCalculating(t,e){return await this.#e?.sync(),this.#t.updateEntityScorecardsStatusIfCalculating(t,e)}async getOutdatedEntities(t){return await this.#e?.sync(),this.#t.getOutdatedEntities(t)}async setEntitiesAsOutdated(t){await this.#e?.sync(),await this.#t.setEntitiesAsOutdated(t)}async getEntitiesCount(t,e,a){return await this.#e?.sync(),this.#t.getEntitiesCount(t,e,a)}async getDuplicatedEntitiesCount(t,e){return await this.#e?.sync(),this.#t.getDuplicatedEntitiesCount(t,e)}}export{n as CatalogEntitiesService};
+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};

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