@redocly/redoc-reef 0.138.0-next.13 → 0.138.0-next.14

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

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

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

@@ -1,27 +0,0 @@
-import type { DatabaseClient } from '../../../../../providers/database/client.js';
-import type { EntityRevisionSummary } from '../../../schemas/read-model-schemas.js';
-export declare class RevisionRepository {
-    #private;
-    constructor(db: DatabaseClient);
-    getCurrentRevisionInfo({ key, version, revision, }: {
-        key: string;
-        version: string | null;
-        revision: string | null;
-    }): Promise<{
-        shouldSetNewCurrentRevision: boolean;
-    }>;
-    markAllRevisionsAsNotCurrent(key: string): Promise<void>;
-    demoteVersion(key: string, version: string): Promise<void>;
-    /**
-     * Ensures that the one of the revisions has current and default version.
-     */
-    ensureDefaultAndCurrentRevisionForKey(key: string): Promise<void>;
-    /**
-     * Determines if entity creation should be skipped.
-     * We only skip if the hash matches the MOST RECENT revision for the same key and version.
-     * This allows creating new revisions when reverting to previous content states.
-     */
-    shouldSkipRevisionCreation(key: string, version: string | null, hash: string, isRootEntity?: boolean, isDeleted?: boolean): Promise<boolean>;
-    listEntityRevisions(entityKey: string, version?: string | null): Promise<EntityRevisionSummary[]>;
-}
-//# sourceMappingURL=revision-repository.d.ts.map

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

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

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

@@ -1,40 +0,0 @@
-import type { DatabaseClient } from '../../../../../providers/database/client.js';
-export declare class VersionRepository {
-    private readonly db;
-    constructor(db: DatabaseClient);
-    markAllVersionsAsNotDefault(key: string): Promise<void>;
-    /**
-     * A version whose most recent revision is soft-deleted counts as not existing.
-     */
-    doesVersionExist(key: string, version: string): Promise<boolean>;
-    /**
-     * Gets the ordered list of live versions for a given key: soft-deleted rows and rows of a
-     * version whose most recent revision is soft-deleted are excluded.
-     * The list is ordered by creation date, and then by version.
-     */
-    getOrderedVersionListForKey(key: string): Promise<{
-        version: string | null;
-        isDefaultVersion: boolean;
-        revision: string;
-        createdAt: Date;
-    }[]>;
-    /**
-     * Helper: Determines the correct entity to promote.
-     * STRATEGY:
-     * 1. Identify the highest SemVer string available.
-     * 2. Filter revisions to ONLY include that SemVer.
-     * 3. Sort those specific revisions by Date to find the tip.
-     */
-    getLatestVersion(versionsList: {
-        version: string | null;
-        isDefaultVersion: boolean;
-        revision: string;
-        createdAt: Date;
-    }[]): {
-        version: string | null;
-        isDefaultVersion: boolean;
-        revision: string;
-        createdAt: Date;
-    } | null;
-}
-//# sourceMappingURL=version-repository.d.ts.map

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

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

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

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

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

@@ -1 +0,0 @@
-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

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

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

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-import type { BffCatalogRelatedEntity } from '@redocly/theme/core/types';
-import type { DatabaseClient } from '../../../../../providers/database/client';
-import type { PaginationParams } from '../../../../../providers/database/pagination/schemas.js';
-import type { ListResult } from '../types.js';
-import type { EntityRelationReadModelSchema } from '../../../schemas/read-model-schemas.js';
-export declare class RelationsReadRepository {
-    #private;
-    constructor(db: DatabaseClient);
-    getRelationsForEntity(key: string, version?: string | null, revision?: string | null): Promise<{
-        targetKey: string;
-        targetRevision: string;
-        sourceToTargetRelation: string;
-        direction: 'outgoing' | 'incoming';
-        priority: number;
-    }[]>;
-    getRelatedEntities({ key, paginationParams, rbacTeams, excludedTypes, excludedEntities, }: {
-        key: string;
-        paginationParams: PaginationParams;
-        rbacTeams?: string[];
-        excludedTypes?: string[];
-        excludedEntities?: string[];
-    }): Promise<ListResult<BffCatalogRelatedEntity>>;
-    getEntitiesRelations(paginationParams?: PaginationParams): Promise<ListResult<EntityRelationReadModelSchema>>;
-    getEntityRelationById(id: string): Promise<EntityRelationReadModelSchema | null>;
-}
-//# sourceMappingURL=relations-read-repository.d.ts.map

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

@@ -1 +0,0 @@
-import{and as $,desc as L,eq as R,sql as i}from"drizzle-orm";import{VERSION_NOT_SPECIFIED as O}from"@redocly/theme/core/constants";import{entitiesTable as e}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{entitiesRelationsTable as t}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js";import{entitiesAttributesTable as C}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-attributes-table.js";import{excludeFieldsFromFilter as W,getFirstFilterFieldValue as T}from"../../../../../providers/database/pagination/filter.js";import{applyPagination as g}from"../../../../../providers/database/pagination/index.js";import{getEffectivePaginationLimit as S}from"../../../../../providers/database/pagination/limit.js";import{createBffRelatedEntityFromQueryRow as H}from"../../mappers/create-bff-related-entity.js";import{mapEntityRelationRow as q}from"../../mappers/map-entity-relation-row.js";import{buildEntitiesExclusionFilter as Y}from"../utils/build-entities-exclusion-filter.js";import{buildRbacFilter as M}from"../utils/build-rbac-filter.js";import{FIELDS_TO_SELECT_FOR_ENTITY_RELATION as p}from"../utils.js";import{createEntityRelationReadModel as A}from"../../mappers/create-entity-relation-read-model.js";class oe{#e;constructor(r){this.#e=r}async getRelationsForEntity(r,n,u){const a=await this.#t(r,n,u);return a?(await this.#e.client.select().from(a).all()).map(c=>q(c)):[]}async getRelatedEntities({key:r,paginationParams:n,rbacTeams:u,excludedTypes:a,excludedEntities:d}){const c=T(n.filter,"version"),y=T(n.filter,"revision"),o=await this.#t(r,c,y);if(!o)return{items:[],total:0};const m=this.#e.client.select({relationType:o.relationName,direction:o.direction,key:e.key,revision:e.revision,id:e.id,type:e.type,title:e.title,summary:e.summary,tags:e.tags,metadata:e.metadata,createdAt:e.createdAt,updatedAt:e.updatedAt,source:e.source,sourceFile:e.sourceFile,version:e.version,isDeleted:e.isDeleted,isCurrent:e.isCurrent,rbacTeams:C.rbacTeams,dedupRn:i`ROW_NUMBER() OVER (PARTITION BY ${o.entityKey} ORDER BY ${o.priority} ASC, CASE WHEN ${o.entityRevision} = ${e.revision} THEN 1 ELSE 0 END DESC, CASE WHEN ${o.entityVersion} = ${e.version} THEN 1 ELSE 0 END DESC, ${e.isCurrent} DESC, ${e.revision} DESC)`.as("dedupRn")}).from(o).innerJoin(e,i`${o.entityKey} = ${e.key} AND (${o.entityRevision} = ${e.revision} OR ${o.entityRevision} = '' OR ${e.isCurrent} = 1) AND (${o.entityVersion} = ${e.version} OR ${o.entityVersion} = '' OR ${e.version} = ${O})`).leftJoin(C,R(e.key,C.entityKey)).as("unique_relations"),f=M(u,"unique_relations"),E=Y(a,d,"unique_relations");let s=i`${m.dedupRn} = 1 AND COALESCE(${m.isDeleted}, 0) = 0`;f&&(s=i`${s} AND ${f}`),E&&(s=i`${s} AND ${E}`);const l=this.#e.client.select().from(m).$dynamic(),V=this.#e.client.select().from(m).$dynamic(),F=W(n.filter,["version","revision"]),D={...n,filter:F,baseWhereCondition:s},w=g(V,{...D,limit:void 0,skip:void 0,after:void 0,before:void 0}),_=this.#e.client.$count(w),N=S(n),b=g(l,{...D,limit:N+1}),[B,K]=await Promise.all([b.all(),_]),h=B.filter(v=>v.id!=null).map(v=>H(v)).filter(v=>v!==null),I=h.slice(0,N),Q=h.length>N;return{items:I,hasMore:Q,total:K}}async getEntitiesRelations(r={}){const n=this.#e.client.select(p).from(t),u=this.#e.client.select(p).from(n.as("combined_entities_relations")).$dynamic(),a=this.#e.client.select(p).from(n.as("combined_entities_relations")).$dynamic(),d=g(a,{...r,limit:void 0,skip:void 0,after:void 0,before:void 0}),c=this.#e.client.$count(d),y=S(r),o=g(u,{...r,limit:y+1}),[m,f]=await Promise.all([o.all(),c]),E=m,s=E.length>y;return{items:E.slice(0,y).map(l=>A(l)).filter(l=>l!==null),hasMore:s,total:f}}async getEntityRelationById(r){const n=await this.#e.client.select(p).from(t).where(R(t.id,r)).get();return n?A(n):null}async#i(r,n){if(n){const c=await this.#e.client.select({version:e.version,revision:e.revision}).from(e).where($(R(e.key,r),R(e.version,n))).orderBy(L(e.revision)).limit(1).get();return c?{version:c.version||null,revision:c.revision||null}:null}const a=await this.#e.client.select({version:e.version,revision:e.revision}).from(e).where($(R(e.key,r),R(e.isCurrent,!0))).limit(1).get();return a?{version:a.version||null,revision:a.revision||null}:null}async#t(r,n,u){const a=u?{version:n||null,revision:u}:await this.#i(r,n||null),d=n||a?.version||null,c=u||a?.revision||null,y=!d||d===O,o=y?i`1 = 1`:i`(${t.sourceVersion} = ${d} OR ${t.sourceVersion} = '')`,m=y?i`1 = 1`:i`(${t.targetVersion} = ${d} OR ${t.targetVersion} = '')`,f=c?i`(${t.sourceRevision} <= ${c} OR ${t.sourceRevision} = '')`:i`1 = 0`,E=c?i`(${t.targetRevision} <= ${c} OR ${t.targetRevision} = '')`:i`1 = 0`,s=this.#e.client.select({entityKey:t.targetKey,entityRevision:t.targetRevision,entityVersion:t.targetVersion,relationName:t.sourceToTargetRelation,direction:i`'outgoing'`.as("direction"),priority:i`1`.as("priority"),isDeleted:t.isDeleted,rn:i`ROW_NUMBER() OVER (PARTITION BY ${t.targetKey}, ${t.sourceToTargetRelation} ORDER BY CASE WHEN ${t.sourceVersion} != '' THEN 1 ELSE 0 END DESC, ${t.sourceRevision} DESC)`.as("rn")}).from(t).where($(R(t.sourceKey,r),o,f)).as("outgoing_filtered"),l=this.#e.client.select({entityKey:t.sourceKey,entityRevision:t.sourceRevision,entityVersion:t.sourceVersion,relationName:t.targetToSourceRelation,direction:i`'incoming'`.as("direction"),priority:i`2`.as("priority"),isDeleted:t.isDeleted,rn:i`ROW_NUMBER() OVER (PARTITION BY ${t.sourceKey}, ${t.targetToSourceRelation} ORDER BY CASE WHEN ${t.targetVersion} != '' THEN 1 ELSE 0 END DESC, ${t.targetRevision} DESC)`.as("rn")}).from(t).where($(R(t.targetKey,r),m,E)).as("incoming_filtered");return this.#e.client.select({entityKey:s.entityKey,entityRevision:s.entityRevision,entityVersion:s.entityVersion,relationName:s.relationName,direction:s.direction,priority:s.priority}).from(s).where(i`${s.rn} = 1 AND COALESCE(${s.isDeleted}, 0) = 0`).unionAll(this.#e.client.select({entityKey:l.entityKey,entityRevision:l.entityRevision,entityVersion:l.entityVersion,relationName:l.relationName,direction:l.direction,priority:l.priority}).from(l).where(i`${l.rn} = 1 AND COALESCE(${l.isDeleted}, 0) = 0`)).as("all_relations")}}export{oe as RelationsReadRepository};

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

@@ -1,28 +0,0 @@
-import type { DatabaseClient } from '../../../../../providers/database/client.js';
-import type { DatabaseEntityRelation, DatabaseEntityRelationDto } from '../../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js';
-import type { Filter } from '../../../../../providers/database/pagination/types.js';
-import type { EntityRelationDtoSchema } from '../../../schemas/dto-schemas.js';
-import type { EntityRelationReadModelSchema } from '../../../schemas/read-model-schemas.js';
-export declare class RelationsWriteRepository {
-    #private;
-    constructor(db: DatabaseClient, organizationId: string, projectId: string);
-    createEntityRelation(entityRelation: EntityRelationDtoSchema): Promise<EntityRelationReadModelSchema | null>;
-    createEntityRelations(relations: EntityRelationDtoSchema[]): Promise<(EntityRelationReadModelSchema | null)[]>;
-    upsertEntityRelation(entityRelation: DatabaseEntityRelationDto): Promise<DatabaseEntityRelation | null>;
-    deleteEntityRelation(id: string): Promise<string | null>;
-    deleteEntitiesRelations(filter: Filter): Promise<boolean>;
-    /**
-     * Deletes entity relations when an entity is removed.
-     * The deletion logic depends on what other revisions exist:
-     * - If this is the only revision of the key: remove all relations with this key (source or target)
-     * - If this is the only revision with given version: remove relations with key+version (any revision)
-     * - Always: remove relations with exact key+version+revision match
-     */
-    deleteEntityRelationsOnEntityRemoval(entity: {
-        id: string;
-        key: string;
-        version?: string | null;
-        revision?: string | null;
-    }): Promise<void>;
-}
-//# sourceMappingURL=relations-write-repository.d.ts.map

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

@@ -1 +0,0 @@
-import{and as a,eq as i,ne as d,or as u,sql as g}from"drizzle-orm";import{entitiesRelationsTable as t}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-relations-table.js";import{logger as c}from"../../../../../tools/notifiers/logger.js";import{entitiesTable as o}from"../../../../../providers/database/databases/sqlite-db/schemas/entities-table.js";import{promiseMapLimit as f}from"../../../../../utils/async/promise-map-limit.js";import{convertFilterToWhereCondition as v}from"../../../../../providers/database/pagination/filter.js";import{createEntityRelationReadModel as p}from"../../mappers/create-entity-relation-read-model.js";import{createEntityRelationDbRecordFromDto as w}from"../../mappers/create-entity-relation-db-record-from-dto.js";const E=15;class U{#e;#t;#r;constructor(r,e,n){this.#e=r,this.#t=e,this.#r=n}async createEntityRelation(r){try{const e=w(r,this.#t,this.#r),n=await this.upsertEntityRelation(e);return p(n)}catch(e){throw c.error("Error creating entity relation",e),e}}async createEntityRelations(r){return await f(r,E,async e=>this.createEntityRelation(e))}async upsertEntityRelation(r){if(!r)return null;try{const{sourceKey:e,targetKey:n,sourceVersion:h,targetVersion:s,sourceRevision:l,targetRevision:m,...R}=r,y=await this.#e.client.insert(t).values(r).onConflictDoUpdate({target:[t.sourceKey,t.targetKey,t.sourceVersion,t.targetVersion,t.sourceRevision,t.targetRevision,t.sourceToTargetRelation],set:R}).returning();return y?.length?y[0]:null}catch(e){return c.error("Error creating entity relation",e),null}}async deleteEntityRelation(r){try{return await this.#e.client.delete(t).where(i(t.id,r)),r}catch(e){return c.error("Error deleting entity relation",e),null}}async deleteEntitiesRelations(r){try{const e=v(r);return e?(await this.#e.client.delete(t).where(e),!0):!1}catch(e){return c.error("Error deleting entities relations",e),!1}}async deleteEntityRelationsOnEntityRemoval(r){const{key:e,version:n,revision:h}=r,s=n??"",l=h??"";if(((await this.#e.client.select({count:g`COUNT(*)`}).from(o).where(a(i(o.key,e),d(o.id,r.id))).get())?.count??0)===0){await this.#e.client.delete(t).where(u(i(t.sourceKey,e),i(t.targetKey,e)));return}if(((await this.#e.client.select({count:g`COUNT(*)`}).from(o).where(a(i(o.key,e),i(o.version,s),d(o.id,r.id))).get())?.count??0)===0){await this.#e.client.delete(t).where(u(a(i(t.sourceKey,e),i(t.sourceVersion,s)),a(i(t.targetKey,e),i(t.targetVersion,s))));return}await this.#e.client.delete(t).where(u(a(i(t.sourceKey,e),i(t.sourceVersion,s),i(t.sourceRevision,l)),a(i(t.targetKey,e),i(t.targetVersion,s),i(t.targetRevision,l))))}}export{U as RelationsWriteRepository};

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

@@ -1,39 +0,0 @@
-import type { EntityDtoSchema } from '../../schemas/dto-schemas';
-import type { EntitySource } from '../../schemas/read-model-schemas';
-export type ListResult<T> = {
-    items: T[];
-    hasMore?: boolean;
-    total: number;
-};
-export type CatalogFiltersParams = {
-    entitiesTypes?: string[];
-    emptyFilters?: string[];
-    rbacTeams?: string[];
-    excludedTypes?: string[];
-    excludedEntities?: string[];
-};
-export type FilterOption = {
-    value: string;
-    count: number;
-};
-export type CreateEntityParams = {
-    entity: EntityDtoSchema;
-    source: EntitySource;
-    revision?: string;
-    fileHash?: string;
-    sourceFile?: string;
-    rbacTeams?: string[];
-    isRootEntity?: boolean;
-    isDeleted?: boolean;
-    errorOnSkip?: boolean;
-};
-export type CreateEntityResult = {
-    result: 'created';
-    entityKey: string;
-    entityRevision: string;
-    entityVersion: string | null;
-} | {
-    result: 'skipped' | 'error';
-    entityKey: string;
-};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,13 +0,0 @@
-import { type SQL } from 'drizzle-orm';
-/**
- * Builds an exclusion filter condition as a drizzle SQL object.
- * Use this with drizzle query builder to exclude specific entity types or keys.
- *
- * Exclusion filter logic:
- * 1. If excludedEntities is provided -> exclude entities matching those keys
- * 2. If excludedTypes is provided -> exclude entities matching those types
- * 3. Multiple conditions are combined with AND
- * 4. Returns undefined if no exclusions are specified
- */
-export declare function buildEntitiesExclusionFilter(excludedTypes?: string[], excludedEntities?: string[], tableAlias?: string): SQL | undefined;
-//# sourceMappingURL=build-entities-exclusion-filter.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/utils/build-entities-exclusion-filter.js

@@ -1 +0,0 @@
-import{sql as n}from"drizzle-orm";function u(r,i,t){const o=[],f=t?n.raw(`${t}.type`):n.raw("type"),p=t?n.raw(`${t}.key`):n.raw("key");if(i?.length&&o.push(n`${p} NOT IN (${n.join(i.map(e=>n`${e}`),n`, `)})`),r?.length)for(const e of r)o.push(n`${f} != ${e}`);if(o.length!==0)return o.length===1?o[0]:n`(${n.join(o,n` AND `)})`}export{u as buildEntitiesExclusionFilter};

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

@@ -1,31 +0,0 @@
-import { type SQL } from 'drizzle-orm';
-/**
- * Builds an RBAC filter condition as a drizzle SQL object.
- * Use this with drizzle query builder.
- *
- * RBAC filter logic:
- * 1. If rbac_teams is NULL -> allow access (no restrictions)
- * 2. If rbac_teams is empty array -> allow access (no restrictions)
- * 3. Otherwise, check if any of user's teams match using json_each
- */
-export declare function buildRbacFilter(rbacTeams?: string[], tableAlias?: string): SQL | undefined;
-/**
- * Builds an RBAC filter condition as a raw SQL string.
- * Use this when constructing raw SQL queries with sql.raw().
- *
- * Same RBAC filter logic as buildRbacFilter but returns a string for raw SQL usage.
- */
-export declare function buildRbacFilterRaw(rbacTeams?: string[], tableAlias?: string): string | null;
-/**
- * Builds RBAC JOIN and filter for subqueries that need to join with combined_target_attributes CTE.
- * Returns both the LEFT JOIN clause and the AND filter condition for use in raw SQL subqueries.
- *
- * @param rbacTeams - Array of team names the user belongs to
- * @param entityKeyAlias - The alias for the entity key column (e.g., 'd.key', 'o.key')
- * @returns Object with `join` and `filter` SQL fragments (both empty if no RBAC teams)
- */
-export declare function buildSubqueryRbacJoinAndFilter(rbacTeams?: string[], entityKeyAlias?: string): {
-    join: SQL;
-    filter: SQL;
-};
-//# sourceMappingURL=build-rbac-filter.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/utils/build-rbac-filter.js

@@ -1,9 +0,0 @@
-import{sql as t}from"drizzle-orm";function E(e,r){if(!e||e.length===0)return;const n=r?`${r}.rbac_teams`:"rbac_teams",a=t.join(e.map(o=>t`${o}`),t`, `);return t`(${t.raw(n)} IS NULL OR json_array_length(COALESCE(${t.raw(n)}, '[]')) = 0 OR EXISTS (SELECT 1 FROM json_each(COALESCE(${t.raw(n)}, '[]')) AS t WHERE t.value IN (${a})))`}function s(e,r){if(!e||e.length===0)return null;const n=r?`${r}.rbac_teams`:"rbac_teams",a=e.map(o=>`'${o.replace(/'/g,"''")}'`).join(", ");return`(${n} IS NULL OR json_array_length(COALESCE(${n}, '[]')) = 0 OR EXISTS (SELECT 1 FROM json_each(COALESCE(${n}, '[]')) AS t WHERE t.value IN (${a})))`}function u(e,r){if(!(e&&e.length>0))return{join:t``,filter:t``};const a=t`LEFT JOIN combined_target_attributes attr ON attr.entity_key = ${t.raw(r??"key")}`,o=t`
-              AND (
-                attr.rbac_teams IS NULL
-                OR json_array_length(attr.rbac_teams) = 0
-                OR EXISTS (
-                  SELECT 1 FROM json_each(attr.rbac_teams) as t
-                  WHERE t.value IN (${t.join(e.map(i=>t`${i}`),t`, `)})
-                )
-              )`;return{join:a,filter:o}}export{E as buildRbacFilter,s as buildRbacFilterRaw,u as buildSubqueryRbacJoinAndFilter};

package/dist/server/plugins/catalog-entities/database/repositories/utils/create-merged-entity-fields-for-select.d.ts

@@ -1,35 +0,0 @@
-import type { SQL } from 'drizzle-orm';
-/**
- * Creates merged entity fields for SELECT when joining remote and local entities.
- * JSON fields (metadata, git, contact, links, tags) are merged using json_patch.
- * Simple fields prefer the newer value based on updated_at.
- * @param remoteAlias - Alias for remote table (default: 'r')
- * @param localAlias - Alias for local table (default: 'l')
- */
-export declare function createMergedEntityFieldsForSelect(remoteAlias?: string, localAlias?: string): {
-    id: SQL<unknown>;
-    organizationId: SQL<unknown>;
-    projectId: SQL<unknown>;
-    key: SQL<unknown>;
-    type: SQL<unknown>;
-    title: SQL<unknown>;
-    summary: SQL<unknown>;
-    tags: SQL<unknown>;
-    metadata: SQL<unknown>;
-    git: SQL<unknown>;
-    contact: SQL<unknown>;
-    links: SQL<unknown>;
-    createdAt: SQL<unknown>;
-    updatedAt: SQL<unknown>;
-    source: SQL<unknown>;
-    sourceFile: SQL<unknown>;
-    fileHash: SQL<unknown>;
-    version: SQL<unknown>;
-    revision: SQL<unknown>;
-    hash: SQL<unknown>;
-    isCurrent: SQL<unknown>;
-    isDefaultVersion: SQL<unknown>;
-    isDeleted: SQL<unknown>;
-    scorecardsStatus: SQL<unknown>;
-};
-//# sourceMappingURL=create-merged-entity-fields-for-select.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/utils/create-merged-entity-fields-for-select.js

@@ -1,13 +0,0 @@
-import{sql as u}from"drizzle-orm";function p(t="r",d="l"){return{id:n("id","id",t,d),organizationId:n("organization_id","organization_id",t,d),projectId:n("project_id","project_id",t,d),key:u.raw(`${t}.key AS key`),type:n("type","type",t,d),title:n("title","title",t,d),summary:n("summary","summary",t,d),tags:_("tags","tags",t,d),metadata:_("metadata","metadata",t,d),git:_("git","git",t,d),contact:_("contact","contact",t,d),links:_("links","links",t,d),createdAt:u.raw(`MIN(${t}.created_at, ${d}.created_at) AS created_at`),updatedAt:u.raw(`MAX(${t}.updated_at, ${d}.updated_at) AS updated_at`),source:n("source","source",t,d),sourceFile:n("source_file","source_file",t,d),fileHash:n("file_hash","file_hash",t,d),version:u.raw(`${t}.version AS version`),revision:u.raw(`${t}.revision AS revision`),hash:n("hash","hash",t,d),isCurrent:n("is_current","is_current",t,d),isDefaultVersion:n("is_default_version","is_default_version",t,d),isDeleted:n("is_deleted","is_deleted",t,d),scorecardsStatus:n("scorecards_status","scorecards_status",t,d)}}function _(t,d,$="r",r="l"){return u.raw(`
-    CASE
-      WHEN ${$}.${t} IS NULL THEN ${r}.${t}
-      WHEN ${r}.${t} IS NULL THEN ${$}.${t}
-      WHEN ${$}.updated_at >= ${r}.updated_at THEN json_patch(${r}.${t}, ${$}.${t})
-      ELSE json_patch(${$}.${t}, ${r}.${t})
-    END AS ${d}
-  `)}function n(t,d,$="r",r="l"){return u.raw(`
-    CASE
-      WHEN ${$}.updated_at >= ${r}.updated_at THEN COALESCE(${$}.${t}, ${r}.${t})
-      ELSE COALESCE(${r}.${t}, ${$}.${t})
-    END AS ${d}
-  `)}export{p as createMergedEntityFieldsForSelect};

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

@@ -1,23 +0,0 @@
-/**
- * Represents a revision with flags that can be normalized.
- */
-export type RevisionWithFlags = {
-    version: string | null;
-    revision: string;
-    isCurrent: boolean;
-    isDefaultVersion: boolean;
-};
-/**
- * Normalizes revision flags to ensure only one revision is marked as current/default.
- *
- * When multiple revisions are flagged (isCurrent or isDefaultVersion), the one with
- * the highest semantic version wins. If versions are equal, the highest revision string wins.
- * All other flagged revisions have their flags reset to false.
- *
- * Note: In this system, isCurrent and isDefaultVersion are coupled - if a revision
- * is current, it is also the default version.
- *
- * @param revisions - Array of revisions to normalize (mutated in place)
- */
-export declare function normalizeRevisionFlags<T extends RevisionWithFlags>(revisions: T[]): void;
-//# sourceMappingURL=normalize-revision-flags.d.ts.map

package/dist/server/plugins/catalog-entities/database/repositories/utils/normalize-revision-flags.js

@@ -1 +0,0 @@
-import{VERSION_NOT_SPECIFIED as t}from"@redocly/theme/core/constants";import{compareVersions as f}from"../../../../../../utils/version/compare-versions.js";function s(r){return!r||r===t}function c(r,i){const e=s(r.version),o=s(i.version);if(e&&!o)return 1;if(!e&&o)return-1;const n=f(i.version??"",r.version??"");return n!==0?n:(i.revision??"").localeCompare(r.revision??"")}function a(r){const i=r.filter(e=>e.isCurrent||e.isDefaultVersion);if(!(i.length<=1)){i.sort(c);for(let e=1;e<i.length;e++)i[e].isCurrent=!1,i[e].isDefaultVersion=!1}}export{a as normalizeRevisionFlags};

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

@@ -1,78 +0,0 @@
-import type { SQL } from 'drizzle-orm';
-/**
- * ============================================================================
- * SEMANTIC VERSION SORTING IN SQLITE
- * ============================================================================
- *
- * SQLite lacks native semantic version comparison, so we convert versions
- * into sortable strings. The key insight is that string comparison uses
- * ASCII/Unicode ordering, so we can control sort order through prefixes
- * and zero-padding.
- *
- * ## Sort Strategy (for descending order)
- *
- * We transform versions into strings that sort correctly when compared lexicographically:
- *
- * | Version Type         | Transformation                      | Example Result          |
- * |----------------------|-------------------------------------|-------------------------|
- * | not_specified_version| Prefix with '!'                     | '!not_specified'        |
- * | null/empty           | Padded zeros                        | '0000000000.0000...'    |
- * | Numeric (1.2.3)      | Zero-padded to 10 digits per part   | '0000000001.0000000002.0000000003' |
- * | Text (latest)        | Prefix with 'Z'                     | 'ZZZZZZZZZZ.latest'     |
- *
- * ASCII ordering ensures: '!' < '0' < 'Z', giving us:
- *   latest > 10.0.0 > 3.1 > 1 > null > not_specified_version
- *
- * ## Why Zero-Padding?
- *
- * Without padding, string comparison fails for multi-digit numbers:
- *   '9' > '10' (wrong!)  vs  '0000000009' < '0000000010' (correct!)
- *
- * We use 10 digits to support versions up to 9,999,999,999 per component.
- */
-/**
- * Builds SQL expression for semantic version sorting in SQLite.
- * Handles versions like: 1, 1.0, 1.0.0, 10.2.3, latest, etc.
- *
- * @param versionColumn - The column name or expression containing the version
- * @returns SQL expression that can be used in ORDER BY for descending version sort
- *
- * @example
- * ```sql
- * ORDER BY ${buildSemanticVersionSortExpr('version')} DESC
- * -- Sorts: latest, 10.0.0, 3.1, 3, 2.0.1, 1, not_specified_version
- * ```
- */
-export declare function buildSemanticVersionSortExpr(versionColumn: string): SQL;
-/**
- * ============================================================================
- * VERSION COMPARISON FILTER
- * ============================================================================
- */
-/**
- * Builds a SQL condition that checks no higher semantic version exists
- * for the same key in either local or remote database.
- *
- * This is used to find the "current" version of an entity when multiple
- * versions exist across local and remote databases.
- *
- * ## Logic
- *
- * Returns TRUE if there is NO other entity with the same key that has:
- *   1. A higher semantic version, OR
- *   2. The same version but a higher revision number
- *
- * ## Example
- *
- * Given entities with key='my-api':
- *   - Local:  version='1.0.0', revision=1
- *   - Remote: version='1.0.0', revision=2  ← This one wins (same version, higher revision)
- *   - Remote: version='2.0.0', revision=1  ← This one wins (higher version)
- *
- * @param keyExpr - SQL expression for the entity's key (e.g., 'entities.key')
- * @param versionExpr - SQL expression for the entity's version (e.g., 'entities.version')
- * @param revisionExpr - SQL expression for the entity's revision (e.g., 'entities.revision')
- * @returns SQL expression that evaluates to TRUE if this is the highest version
- */
-export declare function buildNoHigherVersionExistsFilter(keyExpr: string, versionExpr: string, revisionExpr: string): SQL;
-//# sourceMappingURL=semantic-version-sort.d.ts.map