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

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

@@ -1,20 +0,0 @@
-import type { EntityReadModelSchema, EntityRelationReadModelSchema } from '../../../schemas/read-model-schemas.js';
-import type { EntityDtoSchema, EntityRelationDtoSchema } from '../../../schemas/dto-schemas.js';
-import type { Filter } from '../../../../../providers/database/pagination/types.js';
-import type { DatabaseConnection, RepositoryInstanceOptions } from '../../../../../providers/database/types.js';
-import { BaseRepository } from '../../../../../providers/database/base-repository.js';
-export declare class CatalogEntitiesRemoteRepository extends BaseRepository {
-    #private;
-    get transactionsManager(): import("../../../../../providers/database/transactions-manager.js").TransactionsManager;
-    constructor(dbConnection: DatabaseConnection);
-    sync(): Promise<void>;
-    static getInstance(options: RepositoryInstanceOptions): Promise<CatalogEntitiesRemoteRepository | null>;
-    createEntity(entity: EntityDtoSchema): Promise<EntityReadModelSchema | null>;
-    updateEntity(incomingEntity: Partial<EntityDtoSchema>, entityToBeUpdated: EntityReadModelSchema): Promise<EntityReadModelSchema | null>;
-    deleteEntity(entityToBeRemoved: EntityReadModelSchema): Promise<string | null>;
-    createEntityRelations(relations: EntityRelationDtoSchema[]): Promise<(EntityRelationReadModelSchema | null)[]>;
-    createEntityRelation(entityRelation: EntityRelationDtoSchema): Promise<EntityRelationReadModelSchema | null>;
-    deleteEntityRelation(id: string): Promise<string | null>;
-    deleteEntitiesRelations(filter: Filter): Promise<boolean>;
-}
-//# sourceMappingURL=catalog-entities-remote-repository.d.ts.map

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

@@ -1 +0,0 @@
-import{and as g,eq as n,ne as C,or as w,sql as p}from"drizzle-orm";import{convertFilterToWhereCondition as D}from"../../../../../providers/database/pagination/filter.js";import{promiseMapLimit as V}from"../../../../../utils/async/promise-map-limit.js";import{sha1 as E}from"../../../../../utils/crypto/sha1.js";import{logger as a}from"../../../../../tools/notifiers/logger.js";import{entitiesTable as i}from"../../../../../providers/database/databases/catalog-sqlite/schemas/entities-table.js";import{telemetryTraceStep as c}from"../../../../../telemetry/helpers/trace-step.js";import{BaseRepository as A}from"../../../../../providers/database/base-repository.js";import{DatabaseConnectionFactory as I}from"../../../../../providers/database/database-connection-factory.js";import{entitiesRelationsTable as r}from"../../../../../providers/database/databases/catalog-sqlite/schemas/entities-relations-table.js";import{VERSION_NOT_SPECIFIED as b}from"@redocly/theme/core/constants";import{createEntityDbRecord as _}from"../../mappers/create-entity-db-record.js";import{createEntityReadModel as k}from"../../mappers/create-entity-read-model.js";import{createEntityRelationDbRecordFromDto as O}from"../../mappers/create-entity-relation-db-record-from-dto.js";import{RevisionRepository as K}from"../common/revision-repository.js";import{VersionRepository as F}from"../common/version-repository.js";import{createEntityRelationReadModel as S}from"../../mappers/create-entity-relation-read-model.js";const L=15;class h extends A{static#r;#t;#i;#n=!1;get transactionsManager(){return this.databaseClient.transactionsManager}constructor(t){super(t),this.#t=new K(t.client),this.#i=new F(t.client)}async sync(){if(!this.#n&&this.isNonRemoteDatabaseMode()){a.warn("Catalog entities database is currently operating in local mode: not connected to the remote database. All changes and data will only persist locally and will not be synced remotely."),this.#n=!0;return}return c("catalog_entities.remote_repository.sync",async()=>{await this.#e(),await this.databaseClient.sync()})}static async getInstance(t){return await c("catalog_entities.remote_repository.get_instance",async e=>{if(!h.#r)try{const o=await I.create("sqld-remote",t);if(!o)return a.error("Failed to create db connection for catalog entities remote repository"),e?.error(new Error("Failed to create db connection for catalog entities remote repository")),h.#r=null,null;h.#r=new h(o)}catch(o){return a.error("Error creating db connection for catalog entities remote repository",o),e?.error(o),h.#r=null,null}return h.#r})}async createEntity(t){return c("catalog_entities.remote_repository.create_entity",async()=>{await this.#e();try{a.info(`Adding entity ${t.key} to remote database`);const{relations:e=[],...o}=t,l=E(JSON.stringify(o)),s=t.version??b,y=t.revision??new Date().toISOString();if(await this.#t.shouldSkipRevisionCreation(t.key,s,l))throw new Error("Entity validation failed: entity already exists");const d=await this.#t.shouldSetNewCurrentRevision({key:t.key,version:s,revision:y}),u=_({entity:{...t,revision:y,hash:l,isCurrent:d,isDefaultVersion:d,version:s},organizationId:this.organizationId,projectId:this.projectId,source:"remote",sourceFile:null,fileHash:null}),{key:m,source:M,...N}=u;d&&(await this.#t.markAllRevisionsAsNotCurrent(m),await this.#i.markAllVersionsAsNotDefault(m));const v=await this.databaseClient.client.insert(i).values(u).onConflictDoUpdate({target:[i.key,i.source,i.revision,i.version],set:N}).returning();return v.length?(e&&await this.createEntityRelations(e.map(R=>({...R,sourceKey:t.key,targetKey:R.key}))),k(v[0])):null}catch(e){throw a.error("Error adding entity",e),e}})}async updateEntity(t,e){return c("catalog_entities.remote_repository.update_entity",async()=>{await this.#e();try{a.info(`Updating entity ${e.key} in remote database`);const o=await this.#t.shouldSetNewCurrentRevision({key:e.key,version:t.version??e.version??b,revision:e.revision});o&&(await this.#t.markAllRevisionsAsNotCurrent(e.key),await this.#i.markAllVersionsAsNotDefault(e.key));const l=_({entity:{...e,...t,hash:E(JSON.stringify({...e,...t})),isCurrent:o,isDefaultVersion:o,createdAt:e.createdAt??void 0},organizationId:this.organizationId,projectId:this.projectId,source:"remote",sourceFile:null,fileHash:null}),{key:s,source:y,scorecardsStatus:f,...d}=l,u=await this.databaseClient.client.insert(i).values(l).onConflictDoUpdate({target:[i.key,i.source,i.revision,i.version],set:{...d,scorecardsStatus:p`CASE WHEN ${i.scorecardsStatus} = 'CALCULATING' THEN 'CANCELLED' ELSE 'OUTDATED' END`}}).returning();return u.length?k(u[0]):null}catch(o){return a.error("Error updating entity",o),null}})}async deleteEntity(t){return c("catalog_entities.remote_repository.delete_entity",async()=>{await this.#e();try{return await this.#o(t),await this.databaseClient.client.delete(i).where(n(i.id,t.id)),await this.#t.ensureDefaultAndCurrentRevisionForKey(t.key),t.id}catch(e){return a.error("Error deleting entity",e),null}})}async createEntityRelations(t){return c("catalog_entities.remote_repository.create_entity_relations",async()=>(await this.#e(),await V(t,L,async e=>this.createEntityRelation(e))))}async createEntityRelation(t){return c("catalog_entities.remote_repository.create_entity_relation",async()=>{if(await this.#e(),!t)return null;try{const e=O(t,this.organizationId,this.projectId),{sourceKey:o,targetKey:l,sourceVersion:s,targetVersion:y,sourceRevision:f,targetRevision:d,...u}=e,m=await this.databaseClient.client.insert(r).values(e).onConflictDoUpdate({target:[r.sourceKey,r.targetKey,r.sourceVersion,r.targetVersion,r.sourceRevision,r.targetRevision,r.sourceToTargetRelation],set:u}).returning();return m.length?S(m[0]):null}catch(e){throw a.error("Error creating entity relation",e),e}})}async deleteEntityRelation(t){return c("catalog_entities.remote_repository.delete_entity_relation",async()=>{await this.#e();try{return await this.databaseClient.client.delete(r).where(n(r.id,t)),t}catch(e){return a.error("Error deleting entity relation",e),null}})}async deleteEntitiesRelations(t){return c("catalog_entities.remote_repository.delete_entities_relations",async()=>{await this.#e();try{const e=D(t);return e?(await this.databaseClient.client.delete(r).where(e),!0):!1}catch(e){return a.error("Error deleting entities relations",e),!1}})}async#o(t){const{key:e,version:o,revision:l}=t,s=o??"",y=l??"";if(((await this.databaseClient.client.select({count:p`COUNT(*)`}).from(i).where(g(n(i.key,e),C(i.id,t.id))).get())?.count??0)===0){await this.databaseClient.client.delete(r).where(w(n(r.sourceKey,e),n(r.targetKey,e)));return}if(((await this.databaseClient.client.select({count:p`COUNT(*)`}).from(i).where(g(n(i.key,e),n(i.version,s),C(i.id,t.id))).get())?.count??0)===0){await this.databaseClient.client.delete(r).where(w(g(n(r.sourceKey,e),n(r.sourceVersion,s)),g(n(r.targetKey,e),n(r.targetVersion,s))));return}await this.databaseClient.client.delete(r).where(w(g(n(r.sourceKey,e),n(r.sourceVersion,s),n(r.sourceRevision,y)),g(n(r.targetKey,e),n(r.targetVersion,s),n(r.targetRevision,y))))}#e(){return c("catalog_entities.remote_repository.db_health",async t=>{if(this.databaseClient.dbClient.$client.closed){const e=new Error("The remote database connection is closed!");throw t?.error(e),e}})}}export{h as CatalogEntitiesRemoteRepository};

package/dist/server/plugins/scorecards/database/repositories/local/scorecards-config-local-repository.js

@@ -1 +0,0 @@
-import{and as o,eq as n,isNull as s}from"drizzle-orm";import{scorecardsConfigTable as r}from"../../../../../providers/database/databases/main-sqlite/schemas/scorecards-config-table.js";class d{#e;constructor(e){this.#e=e}async findActiveConfigByKey(e){return(await this.#e.client.select().from(r).where(o(n(r.key,e),s(r.archivedAt))).limit(1))[0]??null}async findAllActiveConfigs(){return await this.#e.client.select().from(r).where(s(r.archivedAt))}async insertConfig(e){const t=await this.#e.client.insert(r).values(e).returning();if(!t[0])throw new Error(`Failed to insert scorecard config with key: ${e.key}`);return t[0]}async updateConfigById(e,t){const i=await this.#e.client.update(r).set(t).where(n(r.id,e)).returning();if(!i[0])throw new Error(`Failed to update scorecard config with id: ${e}`);return i[0]}async archiveConfigById(e,t){const i=await this.#e.client.update(r).set({archivedAt:t}).where(n(r.id,e)).returning();if(!i[0])throw new Error(`Failed to archive scorecard config with id: ${e}`);return i[0]}}export{d as ScorecardsConfigLocalRepository};

package/dist/server/providers/database/database-initialization-strategy.d.ts

@@ -1,17 +0,0 @@
-import type { DatabaseConnectionOptions, DatabaseConnection, DatabaseConnectionInitOptions, RemoteDatabaseConnectionInitOptions } from './types.js';
-export type DatabaseInitializationStrategy = {
-    initialize(options: DatabaseConnectionOptions): Promise<DatabaseConnection>;
-};
-export declare class LocalDatabaseInitializationStrategy implements DatabaseInitializationStrategy {
-    initialize({ removeExisting, baseDbDir, runWithPragmaWalWriteOptimization, databaseName, additionalFolder, migrationsFolder, }: DatabaseConnectionInitOptions): Promise<DatabaseConnection>;
-}
-type RemoteDatabaseInitializationStrategyParams = {
-    skipLogs?: boolean;
-};
-export declare class RemoteDatabaseInitializationStrategy implements DatabaseInitializationStrategy {
-    #private;
-    constructor(params?: RemoteDatabaseInitializationStrategyParams);
-    initialize({ removeExisting, baseDbDir, syncUrl, authToken, databaseName, additionalFolder, migrationsFolder, }: RemoteDatabaseConnectionInitOptions): Promise<DatabaseConnection>;
-}
-export {};
-//# sourceMappingURL=database-initialization-strategy.d.ts.map

package/dist/server/providers/database/database-initialization-strategy.js

@@ -1 +0,0 @@
-import{logger as n}from"../../tools/notifiers/logger.js";import{DatabaseClient as g}from"./client.js";import{DatabasePathGenerator as p}from"./database-path-generator.js";import{retryAsyncOperation as f}from"./utils/retry-async-operation.js";import{SqldNotRunningError as d}from"./sqld-not-running-error.js";class R{async initialize({removeExisting:i,baseDbDir:a,runWithPragmaWalWriteOptimization:o,databaseName:s,additionalFolder:l,migrationsFolder:c}){n.info("Initializing local database client...");const m=n.startTiming(),{databasePath:r}=await p.prepareDatabasePath({baseDir:a,databaseName:s,additionalFolder:l,removeExisting:i}),t={url:`file:${r}`},e=await g.init(t,{runWithPragmaWalWriteOptimization:o});return await e.migrate(a,c),n.infoTime(m,"Local database client initialized"),{client:e,path:r}}}class x{#i;#t;constructor(i){this.#i=i?.skipLogs??!1,this.#t=this.#i?void 0:n}async initialize({removeExisting:i,baseDbDir:a,syncUrl:o,authToken:s,databaseName:l,additionalFolder:c,migrationsFolder:m}){this.#t?.info("Initializing remote database client...");const r=this.#t?.startTiming();return await f(async()=>{try{const{databasePath:t}=await p.prepareDatabasePath({baseDir:a,databaseName:l,additionalFolder:c,removeExisting:i}),e=await g.init({url:`file:${t}`,syncUrl:o,authToken:s});return await e.migrate(a,m),this.#t?.infoTime(r??"","Remote database client initialized"),{client:e,path:t}}catch(t){throw d.isSqldNotRunningError(t)?new d("SQLD server is not running yet, wait for production deployment",{cause:t}):t}},{maxRetries:3,retryStrategy:"exponential",delay:1e3,logger:this.#t,messages:{retry:"Retrying remote database client initialization",maxRetriesReached:"Max retries reached, remote database client initialization failed"}})}}export{R as LocalDatabaseInitializationStrategy,x as RemoteDatabaseInitializationStrategy};

package/dist/server/providers/database/databases/catalog-sqlite/drizzle.config.d.ts

@@ -1,11 +0,0 @@
-export declare const SCHEMAS_PATH = "./src/server/providers/database/databases/catalog-sqlite/schemas/*";
-declare const _default: {
-    schema: string;
-    out: string;
-    dialect: "turso";
-    dbCredentials: {
-        url: string;
-    };
-};
-export default _default;
-//# sourceMappingURL=drizzle.config.d.ts.map

package/dist/server/providers/database/databases/catalog-sqlite/drizzle.config.js

@@ -1 +0,0 @@
-import{DatabasePathGenerator as a}from"../../database-path-generator.js";import{CATALOG_LOCAL_DATABASE_NAME as e,CATALOG_LOCAL_DATABASE_FOLDER as t}from"../../constants.js";const s="./dist/server/esbuild/cache/server",r="./src/server/providers/database/databases/catalog-sqlite/schemas/*",A="./src/server/providers/database/databases/catalog-sqlite/migrations",o=()=>({url:a.generateDatabasePath({baseDir:s,databaseName:e,additionalFolder:t})});var c={schema:r,out:A,dialect:"turso",dbCredentials:o()};export{r as SCHEMAS_PATH,c as default};

package/dist/server/providers/database/databases/catalog-sqlite/migrations/0001_catalog-versions-and-revisions.sql

@@ -1,20 +0,0 @@
-DROP INDEX `idx_entities_relations_source_key_target_to_source_relation_target_key`;--> statement-breakpoint
-ALTER TABLE `entities_relations` ADD `source_version` text;--> statement-breakpoint
-ALTER TABLE `entities_relations` ADD `source_revision` text;--> statement-breakpoint
-ALTER TABLE `entities_relations` ADD `target_version` text;--> statement-breakpoint
-ALTER TABLE `entities_relations` ADD `target_revision` text;--> statement-breakpoint
-CREATE UNIQUE INDEX `idx_entities_relations_unique` ON `entities_relations` (`source_key`,`target_key`,`source_version`,`target_version`,`source_revision`,`target_revision`);--> statement-breakpoint
-ALTER TABLE `entities_relations` DROP COLUMN `schema_version`;--> statement-breakpoint
-DROP INDEX `entities_key_unique`;--> statement-breakpoint
-DROP INDEX `idx_entities_key_source`;--> statement-breakpoint
-ALTER TABLE `entities` ADD `version` text;--> statement-breakpoint
-ALTER TABLE `entities` ADD `revision` text;--> statement-breakpoint
-ALTER TABLE `entities` ADD `hash` text;--> statement-breakpoint
-ALTER TABLE `entities` ADD `is_current` integer DEFAULT true;--> statement-breakpoint
-ALTER TABLE `entities` ADD `is_default_version` integer DEFAULT false;--> statement-breakpoint
-CREATE INDEX `idx_entities_hash` ON `entities` (`hash`);--> statement-breakpoint
-CREATE INDEX `idx_entities_key_source_created_at` ON `entities` (`key`,`created_at`);--> statement-breakpoint
-CREATE INDEX `idx_entities_key_source_is_current` ON `entities` (`key`,`is_current`);--> statement-breakpoint
-CREATE INDEX `idx_entities_key_source_is_default` ON `entities` (`key`,`is_default_version`);--> statement-breakpoint
-CREATE UNIQUE INDEX `idx_entities_key_source` ON `entities` (`key`,`source`,`revision`,`version`);--> statement-breakpoint
-ALTER TABLE `entities` DROP COLUMN `schema_version`;

package/dist/server/providers/database/databases/catalog-sqlite/migrations/0002_add-scorecards-status.sql

@@ -1 +0,0 @@
-ALTER TABLE `entities` ADD `scorecards_status` text;

package/dist/server/providers/database/databases/catalog-sqlite/migrations/0003_catalog_versions_and_revisions_relations.sql

@@ -1,46 +0,0 @@
-DROP INDEX IF EXISTS `idx_entities_relations_source_key`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_relations_target_key`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_relations_source_target`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_relations_target_source`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_relations_unique`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_type`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_hash`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_key_source_created_at`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_key_source_is_current`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_key_source_is_default`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_key_source`;--> statement-breakpoint
--- Update all NULL values to '' first before creating unique index
-UPDATE `entities_relations` SET "source_version" = '' WHERE "source_version" IS NULL;--> statement-breakpoint
-UPDATE `entities_relations` SET "source_revision" = '' WHERE "source_revision" IS NULL;--> statement-breakpoint
-UPDATE `entities_relations` SET "target_version" = '' WHERE "target_version" IS NULL;--> statement-breakpoint
-UPDATE `entities_relations` SET "target_revision" = '' WHERE "target_revision" IS NULL;--> statement-breakpoint
--- Delete duplicate relations keeping only the most recent one (by id)
-DELETE FROM `entities_relations` WHERE `id` NOT IN (
-  SELECT MAX(`id`) FROM `entities_relations`
-  GROUP BY `source_key`, `target_key`, `source_version`, `target_version`, `source_revision`, `target_revision`
-);--> statement-breakpoint
--- We need to set default value to '', because NULL is not unique in sqlite
-ALTER TABLE `entities_relations` ALTER COLUMN "source_version" TO "source_version" text NOT NULL DEFAULT '';--> statement-breakpoint
-ALTER TABLE `entities_relations` ALTER COLUMN "source_revision" TO "source_revision" text NOT NULL DEFAULT '';--> statement-breakpoint
-ALTER TABLE `entities_relations` ALTER COLUMN "target_version" TO "target_version" text NOT NULL DEFAULT '';--> statement-breakpoint
-ALTER TABLE `entities_relations` ALTER COLUMN "target_revision" TO "target_revision" text NOT NULL DEFAULT '';--> statement-breakpoint
-ALTER TABLE `entities_relations` ADD `is_deleted` integer DEFAULT false;--> statement-breakpoint
-CREATE INDEX `idx_entities_relations_source_key` ON `entities_relations` (`source_key`,`is_deleted`);--> statement-breakpoint
-CREATE INDEX `idx_entities_relations_target_key` ON `entities_relations` (`target_key`,`is_deleted`);--> statement-breakpoint
-CREATE INDEX `idx_entities_relations_source_target` ON `entities_relations` (`source_to_target_relation`);--> statement-breakpoint
-CREATE INDEX `idx_entities_relations_target_source` ON `entities_relations` (`target_to_source_relation`);--> statement-breakpoint
-CREATE UNIQUE INDEX `idx_entities_relations_unique` ON `entities_relations` (`source_key`,`target_key`,`source_version`,`target_version`,`source_revision`,`target_revision`);--> statement-breakpoint
-CREATE INDEX `idx_entities_type` ON `entities` (`type`);--> statement-breakpoint
-CREATE INDEX `idx_entities_hash` ON `entities` (`hash`);--> statement-breakpoint
-CREATE INDEX `idx_entities_key_source_created_at` ON `entities` (`key`,`created_at`);--> statement-breakpoint
-ALTER TABLE `entities` ADD `is_deleted` integer DEFAULT false;--> statement-breakpoint
-CREATE INDEX `idx_entities_key_source_is_current` ON `entities` (`key`,`is_current`,`is_deleted`);--> statement-breakpoint
-CREATE INDEX `idx_entities_key_source_is_default` ON `entities` (`key`,`is_default_version`);--> statement-breakpoint
-CREATE UNIQUE INDEX `idx_entities_key_source` ON `entities` (`key`,`source`,`revision`,`version`);--> statement-breakpoint
-ALTER TABLE `entities_relations` DROP COLUMN `source_id`;--> statement-breakpoint
-ALTER TABLE `entities_relations` DROP COLUMN `target_id`;--> statement-breakpoint
-DROP INDEX IF EXISTS `idx_entities_key_source_is_current`;--> statement-breakpoint
-UPDATE `entities` SET "version" = 'not_specified_version' WHERE "version" IS NULL;--> statement-breakpoint
-ALTER TABLE `entities` ALTER COLUMN "version" TO "version" text NOT NULL DEFAULT 'not_specified_version';--> statement-breakpoint
-UPDATE `entities` SET "revision" = '' WHERE "revision" IS NULL;--> statement-breakpoint
-ALTER TABLE `entities` ALTER COLUMN "revision" TO "revision" text NOT NULL;

package/dist/server/providers/database/databases/catalog-sqlite/migrations/0004_normalize_relation_types.sql

@@ -1,147 +0,0 @@
--- Migration: Normalize relation types to canonical forms
--- This migration transforms bidirectional relation types to their canonical forms
--- by swapping source and target entities where needed.
-
--- Normalize ownedBy -> owns (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'owns',
-  target_to_source_relation = 'reverse:owns'
-WHERE source_to_target_relation = 'ownedBy';--> statement-breakpoint
-
--- Normalize partOf -> hasParts (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'hasParts',
-  target_to_source_relation = 'reverse:hasParts'
-WHERE source_to_target_relation = 'partOf';--> statement-breakpoint
-
--- Normalize createdBy -> creates (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'creates',
-  target_to_source_relation = 'reverse:creates'
-WHERE source_to_target_relation = 'createdBy';--> statement-breakpoint
-
--- Normalize implementedBy -> implements (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'implements',
-  target_to_source_relation = 'reverse:implements'
-WHERE source_to_target_relation = 'implementedBy';--> statement-breakpoint
-
--- Normalize dependencyOf -> dependsOn (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'dependsOn',
-  target_to_source_relation = 'reverse:dependsOn'
-WHERE source_to_target_relation = 'dependencyOf';--> statement-breakpoint
-
--- Normalize usedBy -> uses (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'uses',
-  target_to_source_relation = 'reverse:uses'
-WHERE source_to_target_relation = 'usedBy';--> statement-breakpoint
-
--- Normalize extendedBy -> extends (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'extends',
-  target_to_source_relation = 'reverse:extends'
-WHERE source_to_target_relation = 'extendedBy';--> statement-breakpoint
-
--- Normalize supersededBy -> supersedes (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'supersedes',
-  target_to_source_relation = 'reverse:supersedes'
-WHERE source_to_target_relation = 'supersededBy';--> statement-breakpoint
-
--- Normalize memberOf -> hasMember (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'hasMember',
-  target_to_source_relation = 'reverse:hasMember'
-WHERE source_to_target_relation = 'memberOf';--> statement-breakpoint
-
--- Normalize triggeredBy -> triggers (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'triggers',
-  target_to_source_relation = 'reverse:triggers'
-WHERE source_to_target_relation = 'triggeredBy';--> statement-breakpoint
-
--- Normalize returnedBy -> returns (swap source and target)
-UPDATE `entities_relations`
-SET 
-  source_key = target_key,
-  target_key = source_key,
-  source_version = target_version,
-  target_version = source_version,
-  source_revision = target_revision,
-  target_revision = source_revision,
-  source_to_target_relation = 'returns',
-  target_to_source_relation = 'reverse:returns'
-WHERE source_to_target_relation = 'returnedBy';
-

package/dist/server/providers/database/databases/catalog-sqlite/migrations/0005_catalog-relations-constraint-fix.sql

@@ -1,2 +0,0 @@
-DROP INDEX `idx_entities_relations_unique`;--> statement-breakpoint
-CREATE UNIQUE INDEX `idx_entities_relations_unique` ON `entities_relations` (`source_key`,`target_key`,`source_version`,`target_version`,`source_revision`,`target_revision`,`source_to_target_relation`);

package/dist/server/providers/database/databases/catalog-sqlite/migrations/0006_add-catalog-entitities-attributes-table.sql

@@ -1,11 +0,0 @@
-CREATE TABLE `entities_attributes` (
-	`id` text PRIMARY KEY NOT NULL,
-	`organization_id` text NOT NULL,
-	`project_id` text NOT NULL,
-	`entity_key` text NOT NULL,
-	`rbac_teams` text,
-	`created_at` text NOT NULL,
-	`updated_at` text NOT NULL
-);
---> statement-breakpoint
-CREATE UNIQUE INDEX `idx_entities_attributes_key` ON `entities_attributes` (`entity_key`);