@jaypie/dynamodb 0.2.0 → 0.3.0

package/dist/cjs/constants.d.ts

@@ -1,6 +1,6 @@
-export { APEX, ARCHIVED_SUFFIX, DELETED_SUFFIX, SEPARATOR } from "@jaypie/vocabulary";
+export { APEX, ARCHIVED_SUFFIX, DELETED_SUFFIX, SEPARATOR, } from "@jaypie/fabric";
 export declare const INDEX_ALIAS = "indexAlias";
 export declare const INDEX_CLASS = "indexClass";
-export declare const INDEX_OU = "indexOu";
+export declare const INDEX_SCOPE = "indexScope";
 export declare const INDEX_TYPE = "indexType";
 export declare const INDEX_XID = "indexXid";

package/dist/cjs/entities.d.ts

@@ -2,12 +2,12 @@ import type { StorableEntity } from "./types.js";
 /**
  * Get a single entity by primary key
  */
-export declare const getEntity: import("@jaypie/vocabulary").ServiceHandlerFunction<Record<string, unknown>, StorableEntity | null>;
+export declare const getEntity: import("@jaypie/fabric").Service<Record<string, unknown>, StorableEntity | null>;
 /**
  * Put (create or replace) an entity
  * Auto-populates GSI index keys via indexEntity
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex StorableEntity objects that can't be coerced by vocabulary's type system.
  */
 export declare function putEntity({ entity, }: {
@@ -17,7 +17,7 @@ export declare function putEntity({ entity, }: {
  * Update an existing entity
  * Auto-populates GSI index keys and sets updatedAt
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex StorableEntity objects that can't be coerced by vocabulary's type system.
  */
 export declare function updateEntity({ entity, }: {
@@ -27,14 +27,14 @@ export declare function updateEntity({ entity, }: {
  * Soft delete an entity by setting deletedAt timestamp
  * Re-indexes with appropriate suffix based on archived/deleted state
  */
-export declare const deleteEntity: import("@jaypie/vocabulary").ServiceHandlerFunction<Record<string, unknown>, boolean>;
+export declare const deleteEntity: import("@jaypie/fabric").Service<Record<string, unknown>, boolean>;
 /**
  * Archive an entity by setting archivedAt timestamp
  * Re-indexes with appropriate suffix based on archived/deleted state
  */
-export declare const archiveEntity: import("@jaypie/vocabulary").ServiceHandlerFunction<Record<string, unknown>, boolean>;
+export declare const archiveEntity: import("@jaypie/fabric").Service<Record<string, unknown>, boolean>;
 /**
  * Hard delete an entity (permanently removes from table)
  * Use with caution - prefer deleteEntity for soft delete
  */
-export declare const destroyEntity: import("@jaypie/vocabulary").ServiceHandlerFunction<Record<string, unknown>, boolean>;
+export declare const destroyEntity: import("@jaypie/fabric").Service<Record<string, unknown>, boolean>;

package/dist/cjs/index.cjs

@@ -3,7 +3,7 @@
 var clientDynamodb = require('@aws-sdk/client-dynamodb');
 var libDynamodb = require('@aws-sdk/lib-dynamodb');
 var errors = require('@jaypie/errors');
-var vocabulary = require('@jaypie/vocabulary');
+var fabric = require('@jaypie/fabric');
 
 // Environment variable names
 const ENV_AWS_REGION = "AWS_REGION";
@@ -83,11 +83,11 @@ function resetClient() {
     tableName = null;
 }
 
-// Re-export shared constants from vocabulary
+// Re-export shared constants from fabric
 // GSI names (derived from DEFAULT_INDEXES)
 const INDEX_ALIAS = "indexAlias";
 const INDEX_CLASS = "indexClass";
-const INDEX_OU = "indexOu";
+const INDEX_SCOPE = "indexScope";
 const INDEX_TYPE = "indexType";
 const INDEX_XID = "indexXid";
 
@@ -95,53 +95,53 @@ const INDEX_XID = "indexXid";
 // Key Builders
 // =============================================================================
 /**
- * Build the indexOu key for hierarchical queries
- * @param ou - The organizational unit (APEX or "{parent.model}#{parent.id}")
+ * Build the indexScope key for hierarchical queries
+ * @param scope - The scope (APEX or "{parent.model}#{parent.id}")
  * @param model - The entity model name
- * @returns Composite key: "{ou}#{model}"
+ * @returns Composite key: "{scope}#{model}"
  */
-function buildIndexOu(ou, model) {
-    return `${ou}${vocabulary.SEPARATOR}${model}`;
+function buildIndexScope(scope, model) {
+    return `${scope}${fabric.SEPARATOR}${model}`;
 }
 /**
  * Build the indexAlias key for human-friendly lookups
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param alias - The human-friendly alias
- * @returns Composite key: "{ou}#{model}#{alias}"
+ * @returns Composite key: "{scope}#{model}#{alias}"
  */
-function buildIndexAlias(ou, model, alias) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${alias}`;
+function buildIndexAlias(scope, model, alias) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${alias}`;
 }
 /**
  * Build the indexClass key for category filtering
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param recordClass - The category classification
- * @returns Composite key: "{ou}#{model}#{class}"
+ * @returns Composite key: "{scope}#{model}#{class}"
  */
-function buildIndexClass(ou, model, recordClass) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${recordClass}`;
+function buildIndexClass(scope, model, recordClass) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${recordClass}`;
 }
 /**
  * Build the indexType key for type filtering
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param type - The type classification
- * @returns Composite key: "{ou}#{model}#{type}"
+ * @returns Composite key: "{scope}#{model}#{type}"
  */
-function buildIndexType(ou, model, type) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${type}`;
+function buildIndexType(scope, model, type) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${type}`;
 }
 /**
  * Build the indexXid key for external ID lookups
- * @param ou - The organizational unit
+ * @param scope - The scope
  * @param model - The entity model name
  * @param xid - The external ID
- * @returns Composite key: "{ou}#{model}#{xid}"
+ * @returns Composite key: "{scope}#{model}#{xid}"
  */
-function buildIndexXid(ou, model, xid) {
-    return `${ou}${vocabulary.SEPARATOR}${model}${vocabulary.SEPARATOR}${xid}`;
+function buildIndexXid(scope, model, xid) {
+    return `${scope}${fabric.SEPARATOR}${model}${fabric.SEPARATOR}${xid}`;
 }
 // =============================================================================
 // New Vocabulary-Based Functions
@@ -155,18 +155,18 @@ function buildIndexXid(ou, model, xid) {
  * @returns Composite key string
  */
 function buildCompositeKey(entity, fields, suffix) {
-    return vocabulary.buildCompositeKey(entity, fields, suffix);
+    return fabric.buildCompositeKey(entity, fields, suffix);
 }
 /**
- * Calculate the organizational unit from a parent reference
+ * Calculate the scope from a parent reference
  * @param parent - Optional parent entity reference
  * @returns APEX ("@") if no parent, otherwise "{parent.model}#{parent.id}"
  */
-function calculateOu(parent) {
+function calculateScope(parent) {
     if (!parent) {
-        return vocabulary.APEX;
+        return fabric.APEX;
     }
-    return vocabulary.calculateOu(parent);
+    return fabric.calculateScope(parent);
 }
 /**
  * Auto-populate GSI index keys on an entity
@@ -174,7 +174,7 @@ function calculateOu(parent) {
  * Uses the model's registered indexes (from vocabulary registry) or
  * DEFAULT_INDEXES if no custom indexes are registered.
  *
- * - indexOu is always populated from ou + model
+ * - indexScope is always populated from scope + model
  * - indexAlias is populated only when alias is present
  * - indexClass is populated only when class is present
  * - indexType is populated only when type is present
@@ -185,9 +185,9 @@ function calculateOu(parent) {
  * @returns The entity with populated index keys
  */
 function indexEntity(entity, suffix = "") {
-    const indexes = vocabulary.getModelIndexes(entity.model);
-    // Cast through unknown to bridge the type gap between StorableEntity and IndexableEntity
-    return vocabulary.populateIndexKeys(entity, indexes, suffix);
+    const indexes = fabric.getModelIndexes(entity.model);
+    // Cast through unknown to bridge the type gap between StorableEntity and IndexableModel
+    return fabric.populateIndexKeys(entity, indexes, suffix);
 }
 
 /**
@@ -197,20 +197,20 @@ function calculateEntitySuffix(entity) {
     const hasArchived = Boolean(entity.archivedAt);
     const hasDeleted = Boolean(entity.deletedAt);
     if (hasArchived && hasDeleted) {
-        return vocabulary.ARCHIVED_SUFFIX + vocabulary.DELETED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX + fabric.DELETED_SUFFIX;
     }
     if (hasArchived) {
-        return vocabulary.ARCHIVED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX;
     }
     if (hasDeleted) {
-        return vocabulary.DELETED_SUFFIX;
+        return fabric.DELETED_SUFFIX;
     }
     return "";
 }
 /**
  * Get a single entity by primary key
  */
-const getEntity = vocabulary.serviceHandler({
+const getEntity = fabric.fabricService({
     alias: "getEntity",
     description: "Get a single entity by primary key",
     input: {
@@ -232,7 +232,7 @@ const getEntity = vocabulary.serviceHandler({
  * Put (create or replace) an entity
  * Auto-populates GSI index keys via indexEntity
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex StorableEntity objects that can't be coerced by vocabulary's type system.
  */
 async function putEntity({ entity, }) {
@@ -251,7 +251,7 @@ async function putEntity({ entity, }) {
  * Update an existing entity
  * Auto-populates GSI index keys and sets updatedAt
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex StorableEntity objects that can't be coerced by vocabulary's type system.
  */
 async function updateEntity({ entity, }) {
@@ -273,7 +273,7 @@ async function updateEntity({ entity, }) {
  * Soft delete an entity by setting deletedAt timestamp
  * Re-indexes with appropriate suffix based on archived/deleted state
  */
-const deleteEntity = vocabulary.serviceHandler({
+const deleteEntity = fabric.fabricService({
     alias: "deleteEntity",
     description: "Soft delete an entity (sets deletedAt timestamp)",
     input: {
@@ -310,7 +310,7 @@ const deleteEntity = vocabulary.serviceHandler({
  * Archive an entity by setting archivedAt timestamp
  * Re-indexes with appropriate suffix based on archived/deleted state
  */
-const archiveEntity = vocabulary.serviceHandler({
+const archiveEntity = fabric.fabricService({
     alias: "archiveEntity",
     description: "Archive an entity (sets archivedAt timestamp)",
     input: {
@@ -347,7 +347,7 @@ const archiveEntity = vocabulary.serviceHandler({
  * Hard delete an entity (permanently removes from table)
  * Use with caution - prefer deleteEntity for soft delete
  */
-const destroyEntity = vocabulary.serviceHandler({
+const destroyEntity = fabric.fabricService({
     alias: "destroyEntity",
     description: "Hard delete an entity (permanently removes from table)",
     input: {
@@ -372,13 +372,13 @@ const destroyEntity = vocabulary.serviceHandler({
  */
 function calculateSuffix$1({ archived, deleted, }) {
     if (archived && deleted) {
-        return vocabulary.ARCHIVED_SUFFIX + vocabulary.DELETED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX + fabric.DELETED_SUFFIX;
     }
     if (archived) {
-        return vocabulary.ARCHIVED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX;
     }
     if (deleted) {
-        return vocabulary.DELETED_SUFFIX;
+        return fabric.DELETED_SUFFIX;
     }
     return "";
 }
@@ -410,16 +410,16 @@ async function executeQuery(indexName, keyValue, options = {}) {
     };
 }
 /**
- * Query entities by organizational unit (parent hierarchy)
- * Uses indexOu GSI
+ * Query entities by scope (parent hierarchy)
+ * Uses indexScope GSI
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex startKey objects that can't be coerced by vocabulary's type system.
  */
-async function queryByOu({ archived = false, ascending = false, deleted = false, limit, model, ou, startKey, }) {
+async function queryByScope({ archived = false, ascending = false, deleted = false, limit, model, scope, startKey, }) {
     const suffix = calculateSuffix$1({ archived, deleted });
-    const keyValue = buildIndexOu(ou, model) + suffix;
-    return executeQuery(INDEX_OU, keyValue, {
+    const keyValue = buildIndexScope(scope, model) + suffix;
+    return executeQuery(INDEX_SCOPE, keyValue, {
         ascending,
         limit,
         startKey,
@@ -429,7 +429,7 @@ async function queryByOu({ archived = false, ascending = false, deleted = false,
  * Query a single entity by human-friendly alias
  * Uses indexAlias GSI
  */
-const queryByAlias = vocabulary.serviceHandler({
+const queryByAlias = fabric.fabricService({
     alias: "queryByAlias",
     description: "Query a single entity by human-friendly alias",
     input: {
@@ -447,16 +447,19 @@ const queryByAlias = vocabulary.serviceHandler({
             description: "Query deleted entities instead of active ones",
         },
         model: { type: String, description: "Entity model name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
     },
-    service: async ({ alias, archived, deleted, model, ou, }) => {
+    service: async ({ alias, archived, deleted, model, scope, }) => {
         const aliasStr = alias;
         const archivedBool = archived;
         const deletedBool = deleted;
         const modelStr = model;
-        const ouStr = ou;
-        const suffix = calculateSuffix$1({ archived: archivedBool, deleted: deletedBool });
-        const keyValue = buildIndexAlias(ouStr, modelStr, aliasStr) + suffix;
+        const scopeStr = scope;
+        const suffix = calculateSuffix$1({
+            archived: archivedBool,
+            deleted: deletedBool,
+        });
+        const keyValue = buildIndexAlias(scopeStr, modelStr, aliasStr) + suffix;
         const result = await executeQuery(INDEX_ALIAS, keyValue, {
             limit: 1,
         });
@@ -467,12 +470,12 @@ const queryByAlias = vocabulary.serviceHandler({
  * Query entities by category classification
  * Uses indexClass GSI
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex startKey objects that can't be coerced by vocabulary's type system.
  */
-async function queryByClass({ archived = false, ascending = false, deleted = false, limit, model, ou, recordClass, startKey, }) {
+async function queryByClass({ archived = false, ascending = false, deleted = false, limit, model, scope, recordClass, startKey, }) {
     const suffix = calculateSuffix$1({ archived, deleted });
-    const keyValue = buildIndexClass(ou, model, recordClass) + suffix;
+    const keyValue = buildIndexClass(scope, model, recordClass) + suffix;
     return executeQuery(INDEX_CLASS, keyValue, {
         ascending,
         limit,
@@ -483,12 +486,12 @@ async function queryByClass({ archived = false, ascending = false, deleted = fal
  * Query entities by type classification
  * Uses indexType GSI
  *
- * Note: This is a regular async function (not serviceHandler) because it accepts
+ * Note: This is a regular async function (not fabricService) because it accepts
  * complex startKey objects that can't be coerced by vocabulary's type system.
  */
-async function queryByType({ archived = false, ascending = false, deleted = false, limit, model, ou, startKey, type, }) {
+async function queryByType({ archived = false, ascending = false, deleted = false, limit, model, scope, startKey, type, }) {
     const suffix = calculateSuffix$1({ archived, deleted });
-    const keyValue = buildIndexType(ou, model, type) + suffix;
+    const keyValue = buildIndexType(scope, model, type) + suffix;
     return executeQuery(INDEX_TYPE, keyValue, {
         ascending,
         limit,
@@ -499,7 +502,7 @@ async function queryByType({ archived = false, ascending = false, deleted = fals
  * Query a single entity by external ID
  * Uses indexXid GSI
  */
-const queryByXid = vocabulary.serviceHandler({
+const queryByXid = fabric.fabricService({
     alias: "queryByXid",
     description: "Query a single entity by external ID",
     input: {
@@ -516,17 +519,20 @@ const queryByXid = vocabulary.serviceHandler({
             description: "Query deleted entities instead of active ones",
         },
         model: { type: String, description: "Entity model name" },
-        ou: { type: String, description: "Organizational unit (@ for root)" },
+        scope: { type: String, description: "Scope (@ for root)" },
         xid: { type: String, description: "External ID" },
     },
-    service: async ({ archived, deleted, model, ou, xid, }) => {
+    service: async ({ archived, deleted, model, scope, xid, }) => {
         const archivedBool = archived;
         const deletedBool = deleted;
         const modelStr = model;
-        const ouStr = ou;
+        const scopeStr = scope;
         const xidStr = xid;
-        const suffix = calculateSuffix$1({ archived: archivedBool, deleted: deletedBool });
-        const keyValue = buildIndexXid(ouStr, modelStr, xidStr) + suffix;
+        const suffix = calculateSuffix$1({
+            archived: archivedBool,
+            deleted: deletedBool,
+        });
+        const keyValue = buildIndexXid(scopeStr, modelStr, xidStr) + suffix;
         const result = await executeQuery(INDEX_XID, keyValue, {
             limit: 1,
         });
@@ -549,13 +555,13 @@ const queryByXid = vocabulary.serviceHandler({
  */
 function calculateSuffix(archived, deleted) {
     if (archived && deleted) {
-        return vocabulary.ARCHIVED_SUFFIX + vocabulary.DELETED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX + fabric.DELETED_SUFFIX;
     }
     if (archived) {
-        return vocabulary.ARCHIVED_SUFFIX;
+        return fabric.ARCHIVED_SUFFIX;
     }
     if (deleted) {
-        return vocabulary.DELETED_SUFFIX;
+        return fabric.DELETED_SUFFIX;
     }
     return "";
 }
@@ -566,8 +572,8 @@ function buildFilterObject(params) {
     const result = {
         model: params.model,
     };
-    if (params.ou !== undefined) {
-        result.ou = params.ou;
+    if (params.scope !== undefined) {
+        result.scope = params.scope;
     }
     if (params.filter) {
         Object.assign(result, params.filter);
@@ -637,14 +643,14 @@ function selectBestIndex(indexes, filterFields) {
  * specific query function (queryByOu, queryByAlias, etc.) to use.
  *
  * @example
- * // Uses indexOu (pk: ["ou", "model"])
- * const allMessages = await query({ model: "message", ou: `chat#${chatId}` });
+ * // Uses indexScope (pk: ["scope", "model"])
+ * const allMessages = await query({ model: "message", scope: `chat#${chatId}` });
  *
  * @example
- * // Uses indexAlias (pk: ["ou", "model", "alias"])
+ * // Uses indexAlias (pk: ["scope", "model", "alias"])
  * const byAlias = await query({
  *   model: "record",
- *   ou: "@",
+ *   scope: "@",
  *   filter: { alias: "my-record" },
  * });
  *
@@ -660,7 +666,7 @@ async function query(params) {
     // Build the combined filter object
     const filterFields = buildFilterObject(params);
     // Get indexes for this model (custom or DEFAULT_INDEXES)
-    const indexes = vocabulary.getModelIndexes(model);
+    const indexes = fabric.getModelIndexes(model);
     // Select the best matching index
     const selectedIndex = selectBestIndex(indexes, filterFields);
     const indexName = selectedIndex.name ?? generateIndexName(selectedIndex.pk);
@@ -703,18 +709,18 @@ function generateIndexName(pk) {
 /**
  * Seed a single entity if it doesn't already exist
  *
- * @param entity - Partial entity with at least alias, model, and ou
+ * @param entity - Partial entity with at least alias, model, and scope
  * @returns true if entity was created, false if it already exists
  */
 async function seedEntityIfNotExists(entity) {
-    if (!entity.alias || !entity.model || !entity.ou) {
-        throw new Error("Entity must have alias, model, and ou to check existence");
+    if (!entity.alias || !entity.model || !entity.scope) {
+        throw new Error("Entity must have alias, model, and scope to check existence");
     }
     // Check if entity already exists
     const existing = await queryByAlias({
         alias: entity.alias,
         model: entity.model,
-        ou: entity.ou,
+        scope: entity.scope,
     });
     if (existing) {
         return false;
@@ -726,7 +732,7 @@ async function seedEntityIfNotExists(entity) {
         id: entity.id ?? crypto.randomUUID(),
         model: entity.model,
         name: entity.name ?? entity.alias,
-        ou: entity.ou,
+        scope: entity.scope,
         sequence: entity.sequence ?? Date.now(),
         updatedAt: entity.updatedAt ?? now,
         ...entity,
@@ -756,15 +762,15 @@ async function seedEntities(entities, options = {}) {
     for (const entity of entities) {
         const alias = entity.alias ?? entity.name ?? "unknown";
         try {
-            if (!entity.model || !entity.ou) {
-                throw new Error("Entity must have model and ou");
+            if (!entity.model || !entity.scope) {
+                throw new Error("Entity must have model and scope");
             }
             // For entities with alias, check existence
             if (entity.alias) {
                 const existing = await queryByAlias({
                     alias: entity.alias,
                     model: entity.model,
-                    ou: entity.ou,
+                    scope: entity.scope,
                 });
                 if (existing && !replace) {
                     result.skipped.push(alias);
@@ -786,7 +792,7 @@ async function seedEntities(entities, options = {}) {
                 id: entity.id ?? crypto.randomUUID(),
                 model: entity.model,
                 name: entity.name ?? entity.alias ?? "Unnamed",
-                ou: entity.ou,
+                scope: entity.scope,
                 sequence: entity.sequence ?? Date.now(),
                 updatedAt: entity.updatedAt ?? now,
                 ...entity,
@@ -802,27 +808,27 @@ async function seedEntities(entities, options = {}) {
     return result;
 }
 /**
- * Export entities by model and organizational unit
+ * Export entities by model and scope
  *
- * - Paginates through all matching entities via queryByOu
+ * - Paginates through all matching entities via queryByScope
  * - Returns entities sorted by sequence (ascending)
  *
  * @param model - The entity model name
- * @param ou - The organizational unit
+ * @param scope - The scope (APEX or "{parent.model}#{parent.id}")
  * @param limit - Optional maximum number of entities to export
  * @returns Export result with entities and count
  */
-async function exportEntities(model, ou, limit) {
+async function exportEntities(model, scope, limit) {
     const entities = [];
     let startKey;
     let remaining = limit;
     do {
         const batchLimit = remaining !== undefined ? Math.min(remaining, 100) : undefined;
-        const { items, lastEvaluatedKey } = await queryByOu({
+        const { items, lastEvaluatedKey } = await queryByScope({
             ascending: true,
             limit: batchLimit,
             model,
-            ou,
+            scope,
             startKey,
         });
         entities.push(...items);
@@ -840,48 +846,48 @@ async function exportEntities(model, ou, limit) {
  * Export entities as a JSON string
  *
  * @param model - The entity model name
- * @param ou - The organizational unit
+ * @param scope - The scope (APEX or "{parent.model}#{parent.id}")
  * @param pretty - Format JSON with indentation (default: true)
  * @returns JSON string of exported entities
  */
-async function exportEntitiesToJson(model, ou, pretty = true) {
-    const { entities } = await exportEntities(model, ou);
+async function exportEntitiesToJson(model, scope, pretty = true) {
+    const { entities } = await exportEntities(model, scope);
     return pretty ? JSON.stringify(entities, null, 2) : JSON.stringify(entities);
 }
 
 Object.defineProperty(exports, "APEX", {
     enumerable: true,
-    get: function () { return vocabulary.APEX; }
+    get: function () { return fabric.APEX; }
 });
 Object.defineProperty(exports, "ARCHIVED_SUFFIX", {
     enumerable: true,
-    get: function () { return vocabulary.ARCHIVED_SUFFIX; }
+    get: function () { return fabric.ARCHIVED_SUFFIX; }
 });
 Object.defineProperty(exports, "DEFAULT_INDEXES", {
     enumerable: true,
-    get: function () { return vocabulary.DEFAULT_INDEXES; }
+    get: function () { return fabric.DEFAULT_INDEXES; }
 });
 Object.defineProperty(exports, "DELETED_SUFFIX", {
     enumerable: true,
-    get: function () { return vocabulary.DELETED_SUFFIX; }
+    get: function () { return fabric.DELETED_SUFFIX; }
 });
 Object.defineProperty(exports, "SEPARATOR", {
     enumerable: true,
-    get: function () { return vocabulary.SEPARATOR; }
+    get: function () { return fabric.SEPARATOR; }
 });
 exports.INDEX_ALIAS = INDEX_ALIAS;
 exports.INDEX_CLASS = INDEX_CLASS;
-exports.INDEX_OU = INDEX_OU;
+exports.INDEX_SCOPE = INDEX_SCOPE;
 exports.INDEX_TYPE = INDEX_TYPE;
 exports.INDEX_XID = INDEX_XID;
 exports.archiveEntity = archiveEntity;
 exports.buildCompositeKey = buildCompositeKey;
 exports.buildIndexAlias = buildIndexAlias;
 exports.buildIndexClass = buildIndexClass;
-exports.buildIndexOu = buildIndexOu;
+exports.buildIndexScope = buildIndexScope;
 exports.buildIndexType = buildIndexType;
 exports.buildIndexXid = buildIndexXid;
-exports.calculateOu = calculateOu;
+exports.calculateScope = calculateScope;
 exports.deleteEntity = deleteEntity;
 exports.destroyEntity = destroyEntity;
 exports.exportEntities = exportEntities;
@@ -896,7 +902,7 @@ exports.putEntity = putEntity;
 exports.query = query;
 exports.queryByAlias = queryByAlias;
 exports.queryByClass = queryByClass;
-exports.queryByOu = queryByOu;
+exports.queryByScope = queryByScope;
 exports.queryByType = queryByType;
 exports.queryByXid = queryByXid;
 exports.resetClient = resetClient;