nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-3FA7FKAV.mjs

@@ -0,0 +1,832 @@
+import {
+  calculateSchemaHash,
+  schemaHashesMatch
+} from "./chunk-5HMZ644B.mjs";
+import {
+  BaseService
+} from "./chunk-2W3DVD7S.mjs";
+import {
+  NextlyError,
+  toDbError
+} from "./chunk-NRUWQ5Z7.mjs";
+
+// src/services/lib/resource-slug-guard.ts
+async function findSlugOwner(adapter, slug) {
+  const collection = await adapter.selectOne(
+    "dynamic_collections",
+    {
+      where: { and: [{ column: "slug", op: "=", value: slug }] },
+      columns: ["id"]
+    }
+  );
+  if (collection?.id) {
+    return {
+      resourceType: "collection",
+      id: collection.id
+    };
+  }
+  const single = await adapter.selectOne("dynamic_singles", {
+    where: { and: [{ column: "slug", op: "=", value: slug }] },
+    columns: ["id"]
+  });
+  if (single?.id) {
+    return {
+      resourceType: "single",
+      id: single.id
+    };
+  }
+  return null;
+}
+async function assertGlobalResourceSlugAvailable(adapter, slug, options) {
+  const owner = await findSlugOwner(adapter, slug);
+  if (!owner) {
+    return;
+  }
+  const isSameResource = owner.resourceType === options?.currentResourceType && owner.id === options?.currentResourceId;
+  if (isSameResource) {
+    return;
+  }
+  throw NextlyError.duplicate({
+    logContext: {
+      slug,
+      conflictResourceType: owner.resourceType,
+      conflictResourceId: owner.id
+    }
+  });
+}
+
+// src/shared/base-registry-service.ts
+import crypto from "crypto";
+var BaseRegistryService = class extends BaseService {
+  constructor(adapter, logger) {
+    super(adapter, logger);
+  }
+  // ============================================================
+  // Shared Query Methods
+  // ============================================================
+  /**
+   * Get a record by slug, returning null if not found.
+   */
+  async getRecordBySlug(slug) {
+    try {
+      const result = await this.adapter.selectOne(
+        this.registryTableName,
+        {
+          where: this.whereEq("slug", slug)
+        }
+      );
+      return result ? this.deserializeRecord(result) : null;
+    } catch (error) {
+      if (NextlyError.is(error)) throw error;
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  /**
+   * Get a record by slug, throwing NOT_FOUND if missing.
+   *
+   * §13.8: public message is generic; identifying details (slug, resource
+   * type) flow through `logContext`, not the wire.
+   */
+  async getRecordOrThrow(slug) {
+    const record = await this.getRecordBySlug(slug);
+    if (!record) {
+      throw NextlyError.notFound({
+        logContext: { entity: this.resourceType, slug }
+      });
+    }
+    return record;
+  }
+  /**
+   * Get all records, optionally filtered by source, migration status, and locked.
+   */
+  async getAllRecords(options) {
+    try {
+      const conditions = this.buildFilterConditions(options);
+      const results = await this.adapter.select(
+        this.registryTableName,
+        {
+          where: conditions.length > 0 ? { and: conditions } : void 0,
+          orderBy: [{ column: "created_at", direction: "asc" }],
+          limit: options?.limit,
+          offset: options?.offset
+        }
+      );
+      return results.map((record) => this.deserializeRecord(record));
+    } catch (error) {
+      if (NextlyError.is(error)) throw error;
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  /**
+   * List records with pagination, search, and total count.
+   */
+  async listRecords(options) {
+    try {
+      const conditions = this.buildFilterConditions(options);
+      if (options?.search) {
+        const searchPattern = `%${options.search}%`;
+        const searchColumns = this.getSearchColumns();
+        conditions.push({
+          or: searchColumns.map((column) => ({
+            column,
+            op: "ILIKE",
+            value: searchPattern
+          }))
+        });
+      }
+      const whereClause = conditions.length > 0 ? { and: conditions } : void 0;
+      const allResults = await this.adapter.select(
+        this.registryTableName,
+        {
+          where: whereClause,
+          columns: ["id"]
+        }
+      );
+      const total = allResults.length;
+      const results = await this.adapter.select(
+        this.registryTableName,
+        {
+          where: whereClause,
+          orderBy: [{ column: "created_at", direction: "asc" }],
+          limit: options?.limit,
+          offset: options?.offset
+        }
+      );
+      return {
+        data: results.map((record) => this.deserializeRecord(record)),
+        total
+      };
+    } catch (error) {
+      if (NextlyError.is(error)) throw error;
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  // ============================================================
+  // Shared Locking & Migration
+  // ============================================================
+  /**
+   * Check if a record is locked (code-first resources are locked).
+   */
+  async checkIsLocked(slug) {
+    const record = await this.getRecordBySlug(slug);
+    return record?.locked ?? false;
+  }
+  /**
+   * Update migration status for a record.
+   */
+  async updateRecordMigrationStatus(slug, status, migrationId) {
+    this.logger.debug("Updating migration status", { slug, status });
+    try {
+      const updateData = {
+        migration_status: status,
+        updated_at: this.formatDateForDb()
+      };
+      if (migrationId) {
+        updateData.last_migration_id = migrationId;
+      }
+      const results = await this.adapter.update(
+        this.registryTableName,
+        updateData,
+        this.whereEq("slug", slug),
+        { returning: "*" }
+      );
+      if (results.length === 0) {
+        throw NextlyError.notFound({
+          logContext: { entity: this.resourceType, slug }
+        });
+      }
+      this.logger.info("Migration status updated", { slug, status });
+    } catch (error) {
+      if (NextlyError.is(error)) throw error;
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  /**
+   * Safely update migration status to 'applied' with table existence verification.
+   *
+   * CRITICAL: Use this instead of updateRecordMigrationStatus when setting status
+   * to 'applied' to prevent the race condition where status is marked as 'applied'
+   * but the table doesn't actually exist.
+   */
+  async updateMigrationStatusWithTableVerification(slug, tableName) {
+    this.logger.debug("Updating migration status with verification", {
+      slug,
+      tableName
+    });
+    try {
+      const tableExists = await this.adapter.tableExists(tableName);
+      if (tableExists) {
+        await this.updateRecordMigrationStatus(
+          slug,
+          "applied"
+        );
+        this.logger.info("Table verified, migration status set to 'applied'", {
+          slug,
+          tableName
+        });
+        return { verified: true, status: "applied" };
+      } else {
+        await this.updateRecordMigrationStatus(
+          slug,
+          "failed"
+        );
+        this.logger.error(
+          "Table verification failed - migration status set to 'failed'",
+          { slug, tableName }
+        );
+        return { verified: false, status: "failed" };
+      }
+    } catch (error) {
+      if (NextlyError.is(error)) throw error;
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  /**
+   * Get all records with pending migrations (status 'pending' or 'generated').
+   */
+  async getRecordsWithPendingMigrations() {
+    try {
+      const results = await this.adapter.select(
+        this.registryTableName,
+        {
+          where: {
+            and: [
+              {
+                column: "migration_status",
+                op: "IN",
+                value: ["pending", "generated"]
+              }
+            ]
+          },
+          orderBy: [{ column: "created_at", direction: "asc" }]
+        }
+      );
+      return results.map((record) => this.deserializeRecord(record));
+    } catch (error) {
+      if (NextlyError.is(error)) throw error;
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  // ============================================================
+  // Shared Utilities
+  // ============================================================
+  /**
+   * Generate a unique ID using crypto.randomUUID().
+   */
+  generateId() {
+    return crypto.randomUUID();
+  }
+  /**
+   * Compute a simple hash from a string (for auto-generating schema_hash).
+   * Uses a fast DJB2-style hash — not cryptographic, just for change detection.
+   */
+  computeSimpleHash(input) {
+    let hash = 5381;
+    for (let i = 0; i < input.length; i++) {
+      hash = (hash << 5) + hash + input.charCodeAt(i) | 0;
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  }
+  /**
+   * Generate a table name from a slug.
+   * Converts slug to snake_case, removes invalid characters, and adds the domain prefix.
+   */
+  generateTableName(slug) {
+    const normalized = slug.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    return `${this.tableNamePrefix}${normalized}`;
+  }
+  /**
+   * Ensure table name has the domain-specific prefix.
+   */
+  ensureTableNamePrefix(tableName) {
+    if (tableName.startsWith(this.tableNamePrefix)) {
+      return tableName;
+    }
+    return `${this.tableNamePrefix}${tableName}`;
+  }
+  /**
+   * Check if admin config has changed between code and database.
+   * Uses JSON comparison to detect changes in admin properties.
+   */
+  adminConfigChanged(codeAdmin, existingAdmin) {
+    if (!codeAdmin && !existingAdmin) {
+      return false;
+    }
+    if (!codeAdmin || !existingAdmin) {
+      return true;
+    }
+    return JSON.stringify(codeAdmin) !== JSON.stringify(existingAdmin);
+  }
+  // ============================================================
+  // Private Helpers
+  // ============================================================
+  /**
+   * Build WHERE conditions for source, migrationStatus, and locked filters.
+   * Returns a mutable array so callers can add additional conditions (e.g., search).
+   */
+  buildFilterConditions(options) {
+    const conditions = [];
+    if (options?.source) {
+      conditions.push({
+        column: "source",
+        op: "=",
+        value: options.source
+      });
+    }
+    if (options?.migrationStatus) {
+      conditions.push({
+        column: "migration_status",
+        op: "=",
+        value: options.migrationStatus
+      });
+    }
+    if (options?.locked !== void 0) {
+      conditions.push({
+        column: "locked",
+        op: "=",
+        value: options.locked
+      });
+    }
+    return conditions;
+  }
+};
+
+// src/domains/collections/services/collection-registry-service.ts
+function describeError(error) {
+  if (NextlyError.is(error)) {
+    const parts = [];
+    parts.push(`[${error.code}] ${error.message}`);
+    if (error.cause instanceof Error && error.cause.message) {
+      parts.push(`cause: ${error.cause.message}`);
+    } else if (typeof error.cause === "string") {
+      parts.push(`cause: ${error.cause}`);
+    }
+    const ctx = error.logContext;
+    if (ctx && typeof ctx === "object" && Object.keys(ctx).length > 0) {
+      try {
+        parts.push(`context: ${JSON.stringify(ctx)}`);
+      } catch {
+      }
+    }
+    return parts.join(" | ");
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var CollectionRegistryService = class extends BaseRegistryService {
+  registryTableName = "dynamic_collections";
+  resourceType = "Collection";
+  tableNamePrefix = "dc_";
+  permissionSeedService;
+  constructor(adapter, logger) {
+    super(adapter, logger);
+  }
+  getSearchColumns() {
+    return ["slug"];
+  }
+  /** Set the PermissionSeedService for auto-seeding permissions on collection sync. */
+  setPermissionSeedService(service) {
+    this.permissionSeedService = service;
+  }
+  async getCollectionBySlug(slug) {
+    return this.getRecordBySlug(slug);
+  }
+  async getCollection(slug) {
+    return this.getRecordOrThrow(slug);
+  }
+  async getAllCollections(options) {
+    return this.getAllRecords(options);
+  }
+  async listCollections(options) {
+    return this.listRecords(options);
+  }
+  async isLocked(slug) {
+    return this.checkIsLocked(slug);
+  }
+  async updateMigrationStatus(slug, status, migrationId) {
+    return this.updateRecordMigrationStatus(slug, status, migrationId);
+  }
+  async updateMigrationStatusWithVerification(slug, tableName) {
+    return this.updateMigrationStatusWithTableVerification(slug, tableName);
+  }
+  async getPendingMigrations() {
+    return this.getRecordsWithPendingMigrations();
+  }
+  async registerCollection(data) {
+    this.logger.debug("Registering collection", { slug: data.slug });
+    await assertGlobalResourceSlugAvailable(this.adapter, data.slug);
+    const existing = await this.getCollectionBySlug(data.slug);
+    if (existing) {
+      throw NextlyError.duplicate({
+        logContext: { reason: "collection-slug-conflict", slug: data.slug }
+      });
+    }
+    const now = this.formatDateForDb();
+    const tableName = this.ensureTableNamePrefix(data.tableName);
+    const fieldsJson = JSON.stringify(data.fields);
+    const schemaHash = data.schemaHash ?? this.computeSimpleHash(fieldsJson);
+    const record = {
+      id: this.generateId(),
+      slug: data.slug,
+      labels: JSON.stringify(data.labels),
+      table_name: tableName,
+      description: data.description,
+      fields: fieldsJson,
+      timestamps: data.timestamps ?? true ? 1 : 0,
+      admin: data.admin ? JSON.stringify(data.admin) : null,
+      source: data.source,
+      locked: data.locked ?? data.source === "code" ? 1 : 0,
+      // Persist Draft/Published flag. Stored as 0/1 to match how
+      // `timestamps` and `locked` are written in this code path; the
+      // SQLite/postgres/mysql Drizzle column types accept either form.
+      status: data.status === true ? 1 : 0,
+      config_path: data.configPath,
+      schema_hash: schemaHash,
+      schema_version: data.schemaVersion ?? 1,
+      migration_status: data.migrationStatus ?? "pending",
+      last_migration_id: data.lastMigrationId,
+      created_by: data.createdBy,
+      hooks: data.hooks ? JSON.stringify(data.hooks) : null,
+      created_at: now,
+      updated_at: now
+    };
+    try {
+      const result = await this.adapter.insert(
+        this.registryTableName,
+        record,
+        { returning: "*" }
+      );
+      this.logger.info("Collection registered", {
+        slug: data.slug,
+        source: data.source
+      });
+      const deserializedRecord = this.deserializeRecord(result);
+      if (this.permissionSeedService && data.slug) {
+        try {
+          const permResult = await this.permissionSeedService.seedCollectionPermissions(
+            data.slug
+          );
+          if (permResult.newPermissionIds?.length > 0) {
+            await this.permissionSeedService.assignNewPermissionsToSuperAdmin(
+              permResult.newPermissionIds
+            );
+          }
+          this.logger.info("Collection permissions seeded", {
+            slug: data.slug,
+            created: permResult.created,
+            total: permResult.total
+          });
+        } catch (permError) {
+          this.logger.error("Failed to seed collection permissions", {
+            slug: data.slug,
+            error: String(permError)
+          });
+        }
+      }
+      return deserializedRecord;
+    } catch (error) {
+      if (NextlyError.is(error)) throw error;
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  async updateCollection(slug, data, options) {
+    this.logger.debug("Updating collection", { slug });
+    const existing = await this.getCollection(slug);
+    const targetSlug = data.slug ?? slug;
+    await assertGlobalResourceSlugAvailable(this.adapter, targetSlug, {
+      currentResourceType: "collection",
+      currentResourceId: existing.id
+    });
+    if (existing.locked && options?.source !== "code") {
+      throw NextlyError.forbidden({
+        logContext: {
+          reason: "collection-locked",
+          slug,
+          source: options?.source
+        }
+      });
+    }
+    const updateData = {
+      updated_at: this.formatDateForDb()
+    };
+    if (data.labels) {
+      updateData.labels = JSON.stringify(data.labels);
+    }
+    if (data.description !== void 0) {
+      updateData.description = data.description;
+    }
+    if (data.fields) {
+      updateData.fields = JSON.stringify(data.fields);
+      updateData.schema_version = existing.schemaVersion + 1;
+      updateData.migration_status = "pending";
+    }
+    if (data.timestamps !== void 0) {
+      updateData.timestamps = data.timestamps;
+    }
+    if (data.admin !== void 0) {
+      updateData.admin = data.admin ? JSON.stringify(data.admin) : null;
+    }
+    if (data.schemaHash) {
+      updateData.schema_hash = data.schemaHash;
+    }
+    if (data.locked !== void 0) {
+      updateData.locked = data.locked;
+    }
+    if (data.configPath !== void 0) {
+      updateData.config_path = data.configPath;
+    }
+    if (data.hooks !== void 0) {
+      updateData.hooks = data.hooks ? JSON.stringify(data.hooks) : null;
+    }
+    if (data.status !== void 0) {
+      updateData.status = data.status === true ? 1 : 0;
+    }
+    try {
+      const results = await this.adapter.update(
+        this.registryTableName,
+        updateData,
+        this.whereEq("slug", slug),
+        { returning: "*" }
+      );
+      if (results.length === 0) {
+        throw NextlyError.notFound({ logContext: { slug } });
+      }
+      this.logger.info("Collection updated", { slug });
+      return this.deserializeRecord(results[0]);
+    } catch (error) {
+      if (NextlyError.is(error)) {
+        throw error;
+      }
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  async deleteCollection(slug) {
+    this.logger.debug("Deleting collection", { slug });
+    const existing = await this.getCollection(slug);
+    if (existing.locked) {
+      throw NextlyError.forbidden({
+        logContext: { reason: "collection-locked-delete", slug }
+      });
+    }
+    try {
+      const count = await this.adapter.delete(
+        this.registryTableName,
+        this.whereEq("slug", slug)
+      );
+      if (count === 0) {
+        throw NextlyError.notFound({ logContext: { slug } });
+      }
+      this.logger.info("Collection deleted", { slug });
+    } catch (error) {
+      if (NextlyError.is(error)) {
+        throw error;
+      }
+      throw NextlyError.fromDatabaseError(toDbError(this.dialect, error));
+    }
+  }
+  async syncCodeFirstCollections(configs) {
+    this.logger.info("Syncing code-first collections", {
+      count: configs.length
+    });
+    const result = {
+      created: [],
+      updated: [],
+      unchanged: [],
+      errors: []
+    };
+    for (const config of configs) {
+      try {
+        const existing = await this.getCollectionBySlug(config.slug);
+        const schemaHash = calculateSchemaHash(config.fields);
+        if (!existing) {
+          await this.registerCollection({
+            slug: config.slug,
+            labels: config.labels,
+            tableName: config.tableName ?? this.generateTableName(config.slug),
+            description: config.description,
+            fields: config.fields,
+            timestamps: config.timestamps ?? true,
+            admin: config.admin,
+            source: "code",
+            locked: true,
+            // Forward Draft/Published flag so code-first collections that
+            // opt in actually write the column on first sync.
+            status: config.status === true,
+            configPath: config.configPath,
+            schemaHash
+          });
+          result.created.push(config.slug);
+          await this.seedPermissionsForCollection(config.slug);
+        } else if (!schemaHashesMatch(schemaHash, existing.schemaHash) || config.status === true !== (existing.status === true)) {
+          await this.updateCollection(
+            config.slug,
+            {
+              labels: config.labels,
+              description: config.description,
+              fields: config.fields,
+              timestamps: config.timestamps,
+              admin: config.admin,
+              configPath: config.configPath,
+              schemaHash,
+              locked: true,
+              status: config.status === true
+            },
+            { source: "code" }
+          );
+          result.updated.push(config.slug);
+          await this.seedPermissionsForCollection(config.slug);
+        } else if (this.adminConfigChanged(config.admin, existing.admin) || this.labelsChanged(config.labels, existing.labels)) {
+          await this.updateCollection(
+            config.slug,
+            {
+              labels: config.labels,
+              admin: config.admin,
+              locked: true
+            },
+            { source: "code" }
+          );
+          result.updated.push(config.slug);
+        } else {
+          await this.seedPermissionsForCollection(config.slug);
+          result.unchanged.push(config.slug);
+        }
+      } catch (error) {
+        const message = describeError(error);
+        const isDuplicate = NextlyError.is(error) && error.code === "DUPLICATE" || message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate") || message.toLowerCase().includes("unique constraint");
+        if (isDuplicate) {
+          const refetched = await this.getCollectionBySlug(config.slug).catch(
+            () => null
+          );
+          if (refetched) {
+            this.logger.warn(
+              `Code-first sync: "${config.slug}" already in DB \u2014 treating as unchanged`,
+              { slug: config.slug }
+            );
+            result.unchanged.push(config.slug);
+          } else {
+            const disambiguatedTableName = `dc_${config.slug.replace(/-/g, "_")}_cf`;
+            try {
+              const retrySchemaHash = calculateSchemaHash(config.fields);
+              await this.registerCollection({
+                slug: config.slug,
+                labels: config.labels,
+                tableName: disambiguatedTableName,
+                description: config.description,
+                fields: config.fields,
+                timestamps: config.timestamps ?? true,
+                admin: config.admin,
+                source: "code",
+                locked: true,
+                configPath: config.configPath,
+                schemaHash: retrySchemaHash
+              });
+              this.logger.warn(
+                `Code-first sync: "${config.slug}" had table_name conflict \u2014 registered with table "${disambiguatedTableName}"`,
+                { slug: config.slug, tableName: disambiguatedTableName }
+              );
+              result.created.push(config.slug);
+            } catch (retryError) {
+              const retryMessage = describeError(retryError);
+              result.errors.push({
+                slug: config.slug,
+                error: `table_name conflict (tried "${disambiguatedTableName}"): ${retryMessage}`
+              });
+            }
+          }
+        } else {
+          result.errors.push({ slug: config.slug, error: message });
+        }
+      }
+    }
+    this.logger.info("Code-first sync completed", {
+      created: result.created.length,
+      updated: result.updated.length,
+      unchanged: result.unchanged.length,
+      errors: result.errors.length
+    });
+    return result;
+  }
+  async registerCollectionInTransaction(tx, data) {
+    await assertGlobalResourceSlugAvailable(this.adapter, data.slug);
+    const existing = await tx.selectOne(
+      this.registryTableName,
+      {
+        where: this.whereEq("slug", data.slug)
+      }
+    );
+    if (existing) {
+      throw NextlyError.duplicate({
+        logContext: {
+          reason: "collection-slug-conflict-tx",
+          slug: data.slug
+        }
+      });
+    }
+    const now = this.formatDateForDb();
+    const record = {
+      id: this.generateId(),
+      slug: data.slug,
+      labels: JSON.stringify(data.labels),
+      table_name: data.tableName,
+      description: data.description,
+      fields: JSON.stringify(data.fields),
+      timestamps: data.timestamps ?? true ? 1 : 0,
+      admin: data.admin ? JSON.stringify(data.admin) : null,
+      source: data.source,
+      locked: data.locked ?? data.source === "code" ? 1 : 0,
+      // Same as registerCollection — persist Draft/Published as 0/1.
+      status: data.status === true ? 1 : 0,
+      config_path: data.configPath,
+      schema_hash: data.schemaHash,
+      schema_version: data.schemaVersion ?? 1,
+      migration_status: data.migrationStatus ?? "pending",
+      last_migration_id: data.lastMigrationId,
+      created_by: data.createdBy,
+      hooks: data.hooks ? JSON.stringify(data.hooks) : null,
+      created_at: now,
+      updated_at: now
+    };
+    const result = await tx.insert(
+      this.registryTableName,
+      record,
+      { returning: "*" }
+    );
+    return this.deserializeRecord(result);
+  }
+  async seedPermissionsForCollection(slug) {
+    if (!this.permissionSeedService) return;
+    try {
+      const result = await this.permissionSeedService.seedCollectionPermissions(slug);
+      if (result.newPermissionIds.length > 0) {
+        await this.permissionSeedService.assignNewPermissionsToSuperAdmin(
+          result.newPermissionIds
+        );
+      }
+      if (result.created > 0) {
+        this.logger.info(
+          `Permissions seeded for collection "${slug}": ${result.created} created, ${result.skipped} already existed`
+        );
+      }
+    } catch (error) {
+      this.logger.warn(
+        `Failed to seed permissions for collection "${slug}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  labelsChanged(codeLabels, existingLabels) {
+    if (!codeLabels && !existingLabels) return false;
+    if (!codeLabels || !existingLabels) return true;
+    const existing = typeof existingLabels === "string" ? JSON.parse(existingLabels) : existingLabels;
+    return codeLabels.singular !== existing.singular || codeLabels.plural !== existing.plural;
+  }
+  deserializeRecord(record) {
+    const r = record;
+    const labels = r.labels || r.labels;
+    const fields = r.fields || r.fields;
+    const admin = r.admin || r.admin;
+    const hooks = r.hooks || r.hooks;
+    const tableName = r.table_name || r.tableName;
+    const configPath = r.config_path || r.configPath;
+    const schemaHash = r.schema_hash || r.schemaHash;
+    const schemaVersion = r.schema_version || r.schemaVersion;
+    const migrationStatus = r.migration_status || r.migrationStatus;
+    const lastMigrationId = r.last_migration_id || r.lastMigrationId;
+    const createdBy = r.created_by || r.createdBy;
+    const createdAt = r.created_at || r.createdAt;
+    const updatedAt = r.updated_at || r.updatedAt;
+    return {
+      id: r.id,
+      slug: r.slug,
+      tableName,
+      description: r.description,
+      labels: typeof labels === "string" ? JSON.parse(labels) : labels,
+      fields: typeof fields === "string" ? JSON.parse(fields) : fields,
+      timestamps: r.timestamps,
+      admin: admin ? typeof admin === "string" ? JSON.parse(admin) : admin : void 0,
+      hooks: hooks ? typeof hooks === "string" ? JSON.parse(hooks) : hooks : void 0,
+      source: r.source,
+      locked: r.locked,
+      // Why: read the new status meta-column, defaulting to false for rows
+      // written before this column existed (legacy data without status set).
+      // SQLite returns 0/1 even with mode:"boolean" in some driver/dialect
+      // combinations, so accept both shapes.
+      status: r.status === 1 || r.status === true,
+      configPath,
+      schemaHash,
+      schemaVersion,
+      migrationStatus,
+      lastMigrationId,
+      createdBy,
+      updatedAt: this.normalizeDbTimestamp(updatedAt),
+      createdAt: this.normalizeDbTimestamp(createdAt)
+    };
+  }
+};
+
+export {
+  assertGlobalResourceSlugAvailable,
+  BaseRegistryService,
+  CollectionRegistryService
+};