rimecms 0.31.5 → 0.32.0

package/dist/adapter-sqlite/area.server.d.ts

@@ -1,48 +1,12 @@
-import { VERSIONS_OPERATIONS } from '../core/collections/versions/operations.js';
-import type { Config } from '../core/config/types.js';
-import type { ConfigContext } from '../core/rime.server.js';
-import type { AreaSlug, GenericDoc, RawDoc } from '../core/types/doc.js';
-import type { GetRegisterType } from '../index.js';
-import type { DeepPartial } from '../util/types.js';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import type { AreaHandle } from '../core/adapter.js';
+import { type HandleDeps } from './rows.server.js';
 /**
- * Creates an area facade for SQLite adapter operations with CRUD functionality.
- * Handles both versioned and non-versioned areas with support for localization.
+ * What the adapter can do to one registered area.
+ *
+ * Exactly one document, so no verb here takes an id — `resolveRowId` below is where the one they
+ * need comes from, and it is the *only* place the difference between the two kinds shows. There is
+ * no `insert` and no `delete`: not refused, absent.
+ *
+ * The collection's builder is `collection.server.ts` beside this.
  */
-declare const createAreaFacade: <const C extends Config>(args: {
-    db: LibSQLDatabase<GetRegisterType<"Schema">>;
-    tables: any;
-    configCtx: ConfigContext<C>;
-}) => {
-    update: Update;
-    createArea: (slug: AreaSlug, values: Partial<GenericDoc>, locale?: string) => Promise<{
-        id: string;
-        versionId: string;
-    } | undefined>;
-    get: Get;
-};
-export default createAreaFacade;
-/****************************************************/
-type Get = (args: {
-    slug: AreaSlug;
-    locale?: string;
-    depth?: number;
-    select?: string[];
-    /** Optional parameter to get a specific version */
-    versionId?: string;
-    /** Optional parameter if versionId is not defined and draft=true
-     * 	it will get the latest doc no matter its status
-     * 	else the published document will be retrieved
-     */
-    draft?: boolean;
-}) => Promise<RawDoc>;
-type Update = (args: {
-    slug: AreaSlug;
-    data: DeepPartial<GenericDoc>;
-    locale?: string;
-    /** Optional parameter to specify direct version update */
-    versionId?: string;
-    versionOperation: (typeof VERSIONS_OPERATIONS)[keyof typeof VERSIONS_OPERATIONS];
-}) => Promise<{
-    id: string;
-}>;
+export declare const createAreaHandle: (deps: HandleDeps) => AreaHandle;

package/dist/adapter-sqlite/area.server.js

@@ -1,320 +1,42 @@
-import { getRequestEvent } from '$app/server';
-import { VERSIONS_OPERATIONS, VersionOperations } from '../core/collections/versions/operations.js';
-import { VERSIONS_STATUS } from '../core/constant.js';
 import { RimeError } from '../core/errors/index.js';
-import { withLocalesSuffix, withVersionsSuffix } from '../core/naming.js';
-import { createBlankDocument } from '../util/doc.js';
-import { eq } from 'drizzle-orm';
-import * as adapterUtil from './util.server.js';
-import { buildWithParam } from './with.server.js';
+import { baseTableName } from './naming.server.js';
+import { bundles } from './rows.server.js';
+import { findManyPrototypes, readPrototype } from './read.server.js';
+import { ensurePrototypeExists, updatePrototype, updateWherePrototype } from './write.server.js';
 /**
- * Creates an area facade for SQLite adapter operations with CRUD functionality.
- * Handles both versioned and non-versioned areas with support for localization.
+ * What the adapter can do to one registered area.
+ *
+ * Exactly one document, so no verb here takes an id — `resolveRowId` below is where the one they
+ * need comes from, and it is the *only* place the difference between the two kinds shows. There is
+ * no `insert` and no `delete`: not refused, absent.
+ *
+ * The collection's builder is `collection.server.ts` beside this.
  */
-const createAreaFacade = (args) => {
-    const { db, tables, configCtx } = args;
+export const createAreaHandle = (deps) => {
+    const { write, read, self } = bundles(deps);
+    const { slug } = self;
     /**
-     * Retrieves an area document. If the area doesn't exist, it creates a blank one.
-     * For versioned areas, returns either a specific version (if versionId is provided)
-     * or the latest/published version.
-     */
-    const get = async ({ slug, locale, select, versionId, draft }) => {
-        const areaConfig = configCtx.areas[slug];
-        if (!areaConfig) {
-            throw new RimeError(RimeError.INIT, slug + ' is not an area, should never happen');
-        }
-        // `db.query[slug]` can't be typed precisely: with a single registered area,
-        // AreaSlug collapses to one string literal and Drizzle infers an overly
-        // precise (and here incorrect) per-table shape instead of the general one.
-        const queryTable = db.query[slug];
-        const hasVersions = !!areaConfig.versions;
-        if (!hasVersions) {
-            const params = {
-                columns: adapterUtil.columnsParams({ table: tables[slug], select }),
-                with: buildWithParam({ slug, select, locale, tables, config: areaConfig }) || undefined
-            };
-            let doc = await queryTable.findFirst(params);
-            if (!doc) {
-                await createArea(slug, createBlankDocument(areaConfig, getRequestEvent()), locale);
-                doc = await queryTable.findFirst(params);
-            }
-            if (!doc) {
-                throw new Error('Database error');
-            }
-            return doc;
-        }
-        else {
-            // First check for record presence
-            const area = await queryTable.findFirst({ id: true });
-            // If no area exists yet, create it
-            if (!area) {
-                await createArea(slug, createBlankDocument(areaConfig, getRequestEvent()), locale);
-            }
-            // Implementation for versioned areas
-            const versionsTable = withVersionsSuffix(slug);
-            const withParam = buildWithParam({
-                slug: versionsTable,
-                select,
-                locale,
-                tables,
-                config: areaConfig
-            });
-            // Handle select columns for version table
-            const versionSelectColumns = adapterUtil.columnsParams({
-                table: tables[versionsTable],
-                select
-            });
-            // Handle select columns for root table
-            const rootSelectColumns = adapterUtil.columnsParams({ table: tables[slug], select });
-            // Configure the query based on whether we want a specific version or the latest
-            // For the "save in a new draft" action we need to get the published version
-            let params;
-            if (versionId) {
-                // If versionId is provided, get that specific version
-                params = {
-                    columns: rootSelectColumns,
-                    with: {
-                        [versionsTable]: {
-                            columns: versionSelectColumns,
-                            with: withParam,
-                            where: eq(tables[versionsTable].id, versionId)
-                        }
-                    }
-                };
-            }
-            else {
-                // get the latest
-                params = {
-                    columns: rootSelectColumns,
-                    with: {
-                        [versionsTable]: {
-                            columns: versionSelectColumns,
-                            with: withParam,
-                            ...adapterUtil.buildPublishedOrLatestVersionParams({
-                                draft,
-                                config: areaConfig,
-                                table: tables[versionsTable]
-                            })
-                        }
-                    }
-                };
-            }
-            const doc = await queryTable.findFirst(params);
-            if (!doc) {
-                throw new RimeError(RimeError.OPERATION_ERROR);
-            }
-            return adapterUtil.mergeRawDocumentWithVersion(doc, versionsTable, select);
-        }
-    };
-    /**
-     * Creates a new area document. For versioned areas, creates both
-     * the root document and its first version. For non-versioned areas,
-     * creates a single document with the provided data.
-     *
-     * @example
-     * // Create a new area
-     * await createArea(
-     *   'settings',
-     *   { theme: 'light', notifications: true },
-     *   'en'
-     * );
+     * The one row, looked up.
      *
-     * @returns For versioned areas, returns object with id and versionId
+     * An area's row is written at boot by `ensureExists`, so a missing one is a boot that did not
+     * run rather than a request that asked for the wrong thing — which is what the message says.
      */
-    const createArea = async (slug, values, locale) => {
-        const now = new Date();
-        const config = configCtx.areas[slug];
-        const hasVersions = !!config.versions;
-        if (hasVersions) {
-            // Create root document first
-            const docId = await adapterUtil.insertTableRecord(db, tables, slug, {
-                createdAt: now,
-                updatedAt: now
-            });
-            // Generate version ID
-            const versionsTableName = withVersionsSuffix(slug);
-            // Prepare data for versions table
-            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(values, {
-                tables,
-                mainTableName: versionsTableName,
-                localesTableName: withLocalesSuffix(versionsTableName),
-                locale,
-                fillNotNull: true
-            });
-            if (config.versions && config.versions.draft) {
-                mainData.status = 'published';
-            }
-            // Insert version record
-            const versionId = await adapterUtil.insertTableRecord(db, tables, versionsTableName, {
-                ownerId: docId,
-                ...mainData,
-                createdAt: now,
-                updatedAt: now
-            });
-            // Insert localized data if needed
-            if (isLocalized && Object.keys(localizedData).length) {
-                await adapterUtil.insertTableRecord(db, tables, withLocalesSuffix(versionsTableName), {
-                    ...localizedData,
-                    ownerId: versionId,
-                    locale: locale
-                });
-            }
-            // Return both IDs for versioned collections
-            return {
-                id: docId,
-                versionId
-            };
-        }
-        else {
-            const tableLocales = withLocalesSuffix(slug);
-            // Prepare data for insertion using the shared utility function
-            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(values, {
-                tables,
-                mainTableName: slug,
-                localesTableName: tableLocales,
-                locale,
-                fillNotNull: true
-            });
-            // Insert main record
-            const createId = await adapterUtil.insertTableRecord(db, tables, slug, {
-                ...mainData
-            });
-            // Insert localized data if needed
-            if (isLocalized) {
-                await adapterUtil.insertTableRecord(db, tables, tableLocales, {
-                    ...localizedData,
-                    ownerId: createId,
-                    locale
-                });
-            }
-        }
-    };
-    /**
-     * Updates an area document using different versioning strategies.
-     * Supports multiple update patterns:
-     * - Simple update for non-versioned areas
-     * - Direct version update for versioned areas
-     * - Creating new versions from existing ones
-     * - Publishing draft versions
-     *
-     * @example
-     * // Update a non-versioned area
-     * const { id, versionId } = await update({
-     *   slug: 'settings',
-     *   data: { theme: 'dark' },
-     *   versionOperation: VERSIONS_OPERATIONS.UPDATE
-     * });
-     *
-     * // Update a specific version
-     * const { id, versionId } = await update({
-     *   slug: 'site-info',
-     *   data: { title: 'Updated Title' },
-     *   versionId: 'v456',
-     *   versionOperation: VERSIONS_OPERATIONS.UPDATE_VERSION
-     * });
-     *
-     * // Create a new draft from published version
-     * const { id, versionId } = await update({
-     *   slug: 'settings',
-     *   data: { theme: 'system' },
-     *   versionOperation: VERSIONS_OPERATIONS.NEW_DRAFT_FROM_PUBLISHED
-     * });
-     *
-     * @returns Object containing the IDs of the updated area and version
-     * @throws RimeError when operation fails or version ID is missing when required
-     */
-    const update = async ({ slug, data, locale, versionId, versionOperation }) => {
-        const now = new Date();
-        const areaConfig = configCtx.areas[slug];
-        const rows = await db.select({ id: tables[slug].id }).from(tables[slug]);
-        const area = rows[0];
-        // Simple update for non-versioned areas
-        if (VersionOperations.isSimpleUpdate(versionOperation)) {
-            // Original implementation for non-versioned areas
-            const keyTableLocales = withLocalesSuffix(slug);
-            // Prepare data for update using the shared utility function
-            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(data, {
-                tables,
-                mainTableName: slug,
-                localesTableName: keyTableLocales,
-                locale
-            });
-            // Update main table
-            await adapterUtil.updateTableRecord(db, tables, slug, {
-                recordId: area.id,
-                data: { ...mainData, updatedAt: now }
-            });
-            // Update localized data if needed
-            if (isLocalized) {
-                await adapterUtil.upsertLocalizedData(db, tables, keyTableLocales, {
-                    ownerId: area.id,
-                    data: localizedData,
-                    locale: locale
-                });
-            }
-            // For non-versioned areas, versionId is the same as id
-            return { id: area.id };
-        }
-        else if (VersionOperations.isSpecificVersionUpdate(versionOperation)) {
-            // Scenario 1: Update a specific version directly
-            if (!versionId) {
-                throw new RimeError(RimeError.OPERATION_ERROR, 'missing versionId @adapter-update-area');
-            }
-            // First, update the root table's updatedAt
-            await db
-                .update(tables[slug])
-                .set({
-                updatedAt: now
-            })
-                .where(eq(tables[slug].id, area.id));
-            const versionsTable = withVersionsSuffix(slug);
-            const versionsLocalesTable = withLocalesSuffix(versionsTable);
-            // Prepare data for update using the shared utility function
-            const { mainData, localizedData, isLocalized } = adapterUtil.prepareSchemaData(data, {
-                tables,
-                mainTableName: versionsTable,
-                localesTableName: versionsLocalesTable,
-                locale
-            });
-            // if draft is enabled on the collection
-            if (areaConfig.versions && areaConfig.versions.draft && mainData.status === 'published') {
-                // update all rows first to draft
-                await db.update(tables[versionsTable]).set({ status: VERSIONS_STATUS.DRAFT });
-            }
-            // Update version directly
-            await adapterUtil.updateTableRecord(db, tables, versionsTable, {
-                recordId: versionId,
-                data: { ...mainData, updatedAt: now }
-            });
-            // Update localized data if needed
-            if (isLocalized) {
-                await adapterUtil.upsertLocalizedData(db, tables, versionsLocalesTable, {
-                    ownerId: versionId,
-                    data: localizedData,
-                    locale: locale
-                });
-            }
-            return { id: area.id };
-        }
-        else if (VersionOperations.isNewVersionCreation(versionOperation)) {
-            // Scenario 2: version creation, update only main table
-            // the creation is handled by the caller update operation
-            await db
-                .update(tables[slug])
-                .set({
-                updatedAt: now
-            })
-                .where(eq(tables[slug].id, area.id));
-            return { id: area.id };
-        }
-        else {
-            throw new RimeError(RimeError.OPERATION_ERROR, 'Unhandled version operation');
+    const resolveRowId = async () => {
+        const table = deps.tables[baseTableName(slug)];
+        const [row] = await deps.db.select({ id: table.id }).from(table);
+        if (!row) {
+            throw new RimeError(RimeError.OPERATION_ERROR, `${slug} has no row; its boot step should have written one`);
         }
+        return row.id;
     };
     return {
-        update,
-        createArea,
-        get
+        slug,
+        config: deps.config,
+        versions: deps.versions,
+        find: (args = {}) => readPrototype(read, { ...args, ...self, id: undefined }),
+        findMany: (args = {}) => findManyPrototypes(read, { ...args, ...self }),
+        update: async (args) => updatePrototype(write, { ...args, slug, versions: deps.versions, id: await resolveRowId() }),
+        updateWhere: (args) => updateWherePrototype(read, { ...args, slug }),
+        ensureExists: (args) => ensurePrototypeExists(write, { ...args, slug, versions: deps.versions })
     };
 };
-export default createAreaFacade;

package/dist/adapter-sqlite/auth.server.d.ts

@@ -1,27 +1,19 @@
-import type { User } from '../core/collections/auth/types.js';
-import type { CollectionSlug } from '../core/types/doc.js';
 import type { GetRegisterType } from '../index.js';
 import type { LibSQLDatabase } from 'drizzle-orm/libsql';
 /**
- * Creates and configures the authentication facade for the SQLite adapter
- * @param args Configuration parameters for the auth facade
- * @returns Object containing all auth-related functions
+ * All that is left of the auth facade: Better-auth's own database adapter.
+ *
+ * It stays because it cannot be phrased in core's vocabulary and should not be — core hands it to
+ * Better-auth and never looks inside. The other six methods went two ways. Three were
+ * `select … from <a prototype's table> where <a column> = ?` and are
+ * `core/features/auth/user.server.ts` now; three read and wrote Better-auth's own tables and are
+ * `core/features/auth/better-auth-tables.server.ts`, reaching them through `adapter.table(slug)`
+ * because those are declared tables rather than a hand-written template.
  */
-declare const createAuthFacade: (args: {
-    db: LibSQLDatabase<GetRegisterType<"Schema">>;
+declare const createAuthHandle: (args: {
+    db: LibSQLDatabase<GetRegisterType<"Relations">>;
     schema: GetRegisterType<"Schema">;
 }) => {
     betterAuthAdapter: (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
-    hasAuthUser: () => Promise<boolean>;
-    getAuthUserId: ({ slug, id }: {
-        slug: CollectionSlug;
-        id: string;
-    }) => Promise<any>;
-    getUserAttributes: ({ authUserId, slug }: GetUserAttributesArgs) => Promise<User | undefined>;
-    isSuperAdmin: (userId: string) => Promise<boolean>;
-};
-export default createAuthFacade;
-type GetUserAttributesArgs = {
-    authUserId: string;
-    slug: CollectionSlug;
 };
+export default createAuthHandle;

package/dist/adapter-sqlite/auth.server.js

@@ -1,84 +1,27 @@
 import { drizzleAdapter } from 'better-auth/adapters/drizzle';
-import { eq } from 'drizzle-orm';
-// import { configureBetterAuth } from './better-auth.server.js';
 /**
- * Creates and configures the authentication facade for the SQLite adapter
- * @param args Configuration parameters for the auth facade
- * @returns Object containing all auth-related functions
+ * All that is left of the auth facade: Better-auth's own database adapter.
+ *
+ * It stays because it cannot be phrased in core's vocabulary and should not be — core hands it to
+ * Better-auth and never looks inside. The other six methods went two ways. Three were
+ * `select … from <a prototype's table> where <a column> = ?` and are
+ * `core/features/auth/user.server.ts` now; three read and wrote Better-auth's own tables and are
+ * `core/features/auth/better-auth-tables.server.ts`, reaching them through `adapter.table(slug)`
+ * because those are declared tables rather than a hand-written template.
  */
-const createAuthFacade = (args) => {
+const createAuthHandle = (args) => {
     const { db, schema } = args;
-    const betterAuthAdapter = drizzleAdapter(db, {
-        provider: 'sqlite',
-        schema: {
-            ...schema,
-            user: schema.authUsers,
-            session: schema.authSessions,
-            account: schema.authAccounts,
-            verification: schema.authVerifications
-        }
-    });
-    const getTable = (name) => schema[name];
-    const isSuperAdmin = async (userId) => {
-        const panelUsersTable = getTable('staff');
-        const [user] = await db
-            .select({ isSuperAdmin: panelUsersTable.isSuperAdmin })
-            .from(panelUsersTable)
-            .where(eq(panelUsersTable.id, userId));
-        if (!user)
-            return false;
-        return user.isSuperAdmin === true;
-    };
-    /**
-     * Retrieves the BetterAuth user ID from a collection row
-     * @returns BetterAuth user ID or null if not found
-     */
-    const getAuthUserId = async ({ slug, id }) => {
-        const userTable = getTable(slug);
-        // @ts-expect-error slug is key of query
-        const user = await db.query[slug].findFirst({ where: eq(userTable.id, id) });
-        if (user) {
-            return user.authUserId;
-        }
-        return null;
-    };
-    /**
-     * Check whether an auth user exists
-     */
-    const hasAuthUser = async () => {
-        const user = await db.query.authUsers.findFirst();
-        return !!user;
-    };
-    /**
-     * Retrieves user attributes from an auth collection
-     * @returns User object or undefined if not found
-     */
-    const getUserAttributes = async ({ authUserId, slug }) => {
-        const table = getTable(slug);
-        const columns = {
-            id: table.id,
-            name: table.name,
-            roles: table.roles,
-            email: table.email
-        };
-        if (slug === 'staff') {
-            columns.isSuperAdmin = table.isSuperAdmin;
-        }
-        const [user] = await db.select(columns).from(table).where(eq(table.authUserId, authUserId));
-        if (!user)
-            return undefined;
-        return {
-            ...user,
-            isStaff: slug === 'staff'
-        };
-    };
     return {
-        betterAuthAdapter,
-        hasAuthUser,
-        getAuthUserId,
-        // deleteAuthUserById,
-        getUserAttributes,
-        isSuperAdmin
+        betterAuthAdapter: drizzleAdapter(db, {
+            provider: 'sqlite',
+            schema: {
+                ...schema,
+                user: schema.authUsers,
+                session: schema.authSessions,
+                account: schema.authAccounts,
+                verification: schema.authVerifications
+            }
+        })
     };
 };
-export default createAuthFacade;
+export default createAuthHandle;

package/dist/adapter-sqlite/blocks.server.d.ts

@@ -1,26 +1,25 @@
-import type { GenericAdapteFacadeArgs } from './types.server.js';
-import type { GenericBlock } from '../core/types/doc.js';
+import type { AdapterDeps } from './types.server.js';
+import type { GenericBlock, PrototypeSlug } from '../core/prototype/types.js';
 import type { WithOptional } from '../util/types.js';
-declare const createBlocksFacade: ({ db, tables }: GenericAdapteFacadeArgs) => {
-    getBlocksTableNames: (slug: string) => string[];
+declare const createBlocksHandle: ({ db, tables }: AdapterDeps) => {
     delete: DeleteBlock;
     create: CreateBlock;
     update: UpdateBlock;
 };
-export default createBlocksFacade;
+export default createBlocksHandle;
 /****************************************************/
 type UpdateBlock = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     block: GenericBlock;
     locale?: string;
 }) => Promise<boolean>;
 type CreateBlock = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     block: WithOptional<GenericBlock, 'id'>;
     ownerId: string;
     locale?: string;
 }) => Promise<boolean>;
 type DeleteBlock = (args: {
-    parentSlug: string;
+    parentSlug: PrototypeSlug;
     block: GenericBlock;
 }) => Promise<boolean>;

package/dist/adapter-sqlite/blocks.server.js

@@ -1,10 +1,17 @@
-import { withLocalesSuffix } from '../core/naming.js';
+import { baseTableName, tableName as buildTableName } from './naming.server.js';
 import { and, eq, getTableColumns } from 'drizzle-orm';
 import { omit } from '../util/object.js';
-import { toPascalCase } from '../util/string.js';
-import { generatePK, transformDataToSchema } from './util.server.js';
-const createBlocksFacade = ({ db, tables }) => {
-    const buildBlockTableName = (slug, blockName) => `${slug}Blocks${toPascalCase(blockName)}`;
+import { generatePK, transformDataToSchema } from './columns.server.js';
+const createBlocksHandle = ({ db, tables }) => {
+    /**
+     * Callers name the owner by slug — the prototype's own, or its versions table's — and the
+     * mapping to a table happens here, so that a table name never travels in a parameter that
+     * names a slug.
+     */
+    const buildBlockTableName = (parentSlug, blockName) => buildTableName({
+        owner: baseTableName(parentSlug),
+        child: { kind: 'blocks', name: blockName }
+    });
     const update = async ({ parentSlug, block, locale }) => {
         const table = buildBlockTableName(parentSlug, block.type);
         const columns = getTableColumns(tables[table]);
@@ -12,16 +19,16 @@ const createBlocksFacade = ({ db, tables }) => {
         if (Object.keys(values).length) {
             await db.update(tables[table]).set(values).where(eq(tables[table].id, block.id));
         }
-        const keyTableLocales = withLocalesSuffix(table);
+        const keyTableLocales = buildTableName({ owner: table, branch: 'locales' });
         if (locale && keyTableLocales in tables) {
             const tableLocales = tables[keyTableLocales];
             const localizedColumns = getTableColumns(tableLocales);
             const localizedValues = transformDataToSchema(omit(['ownerId', 'id'], block), localizedColumns);
             if (!Object.keys(localizedValues).length)
                 return true;
-            //@ts-expect-error keyTableLocales is key of db.query
+            // @ts-expect-error suck
             const localizedRow = await db.query[keyTableLocales].findFirst({
-                where: and(eq(tableLocales.ownerId, block.id), eq(tableLocales.locale, locale))
+                where: { ownerId: block.id, locale }
             });
             if (!localizedRow) {
                 await db.insert(tableLocales).values({
@@ -48,7 +55,7 @@ const createBlocksFacade = ({ db, tables }) => {
     const create = async ({ parentSlug, block, ownerId, locale }) => {
         const tableName = buildBlockTableName(parentSlug, block.type);
         const blockId = generatePK();
-        const tableNameLocales = withLocalesSuffix(tableName);
+        const tableNameLocales = buildTableName({ owner: tableName, branch: 'locales' });
         if (locale && tableNameLocales in tables) {
             const unlocalizedColumns = getTableColumns(tables[tableName]);
             const localizedColumns = getTableColumns(tables[tableNameLocales]);
@@ -78,12 +85,10 @@ const createBlocksFacade = ({ db, tables }) => {
         }
         return true;
     };
-    const getBlocksTableNames = (slug) => Object.keys(tables).filter((key) => key.startsWith(`${slug}Blocks`) && !key.endsWith('Locales'));
     return {
-        getBlocksTableNames,
         delete: deleteBlock,
         create,
         update
     };
 };
-export default createBlocksFacade;
+export default createBlocksHandle;