@aventara/testing 1.0.0-rc.3 → 1.0.0-rc.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @aventara/testing
 
+## 1.0.0-rc.4
+
+### Patch Changes
+
+- Updated dependencies [e3d03a7]
+- Updated dependencies [d10639a]
+- Updated dependencies [f67e68c]
+- Updated dependencies [708556c]
+- Updated dependencies [3a0dfca]
+- Updated dependencies [99169d2]
+- Updated dependencies [0fd2608]
+- Updated dependencies [154e440]
+- Updated dependencies [2fcffdb]
+  - @aventara/core@1.0.0-rc.4
+
 ## 1.0.0-rc.3
 
 ### Patch Changes

package/dist/protocol/corpus-contract.fixture.d.ts

@@ -1,5 +1,6 @@
-import type { AvContext, AvFramework } from "@aventara/core";
+import type { AvAdapterModel, AvContext, AvFramework, AvPrebuiltContracts } from "@aventara/core";
 import { AvDecimal } from "@aventara/core";
+import type { AvAdapterOperation } from "@aventara/core/internal";
 /**
  * The corpus's adapter model:
  *
@@ -421,13 +422,100 @@ export declare const CORPUS_SAMPLE: {
     readonly blob: Uint8Array<ArrayBuffer>;
 };
 /**
- * A fresh corpus Framework, and the count of operations its Adapter has been
- * handed so far — a row's `adapterCalls` is read from it. `contractHash`
- * selects which corpus ClientContract it serves: the `transactions: "none"`
- * one when it is {@link CORPUS_NONE_CLIENT_CONTRACT_HASH}, the main one
+ * The corpus Framework's configuration, over a fresh corpus Adapter, and the
+ * count of operations that Adapter has been handed so far. `contractHash`
+ * selects which corpus ClientContract it compiles to: the `transactions:
+ * "none"` one when it is {@link CORPUS_NONE_CLIENT_CONTRACT_HASH}, the main one
  * otherwise (a stale or absent hash included).
  */
-export declare function createCorpusFramework(contractHash?: string): Promise<{
+export declare function corpusConfiguration(contractHash?: string): {
+    config: {
+        api: string;
+        adapter: import("@aventara/core").AvAdapter<AvAdapterModel> & {
+            readonly operations: readonly AvAdapterOperation<AvAdapterModel>[];
+            readonly transactions: readonly import("../adapters/fake-adapter.js").AvFakeTransactionTrace<AvAdapterModel>[];
+        } & {
+            transaction?: <T>(work: (executor: import("@aventara/core/internal").AvAdapterTransactionExecutor<AvAdapterModel>) => Promise<T>) => Promise<T>;
+            referentialActions: {
+                readonly books: readonly [{
+                    readonly field: "author";
+                    readonly target: "authors";
+                    readonly references: readonly ["authorId"];
+                    readonly onDelete: "cascade";
+                }];
+            };
+        };
+        resources: {
+            readonly books: {
+                readonly fields: {
+                    readonly label: {
+                        readonly definition: {
+                            readonly type: {
+                                readonly scalar: "string";
+                            };
+                            readonly nullable: false;
+                            readonly list: false;
+                            readonly lifecycle: readonly ["VIRTUAL"];
+                        };
+                        readonly pipelines: {
+                            readonly compute: {
+                                readonly read: {
+                                    readonly dependsOn: readonly ["id"];
+                                    readonly compute: ({ record, }: {
+                                        readonly record: Readonly<Record<string, unknown>>;
+                                    }) => string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        application: {
+            readonly exposed: true;
+            readonly exemptions: {
+                readonly resources: {
+                    readonly books: {
+                        readonly fields: {
+                            readonly label: true;
+                        };
+                    };
+                };
+            };
+        };
+        client: {
+            readonly pipelines: {
+                readonly guards: readonly [typeof corpusGuard];
+                readonly pipes: readonly [typeof corpusPipe];
+            };
+            readonly exposed: true;
+            readonly exemptions: {
+                readonly resources: {
+                    readonly authors: {
+                        readonly fields: {
+                            readonly secret: true;
+                        };
+                    };
+                    readonly secrets: {
+                        readonly operations: {
+                            readonly find: readonly ["many"];
+                        };
+                    };
+                    readonly hiddenRes: true;
+                };
+            };
+        };
+    };
+    adapterCalls: () => number;
+};
+/**
+ * A fresh corpus Framework, and the count of operations its Adapter has been
+ * handed so far — a row's `adapterCalls` is read from it. `contractHash` selects
+ * which corpus ClientContract it serves ({@link corpusConfiguration}). With
+ * `prebuilt`, its Contracts are loaded from that file when it matches, as a
+ * serverless deployment's would be.
+ */
+export declare function createCorpusFramework(contractHash?: string, prebuilt?: AvPrebuiltContracts): Promise<{
     readonly framework: AvFramework;
     readonly adapterCalls: () => number;
 }>;

package/dist/protocol/corpus-contract.fixture.js

@@ -238,7 +238,7 @@ function failingCommit(transaction) {
         return result;
     };
 }
-export async function createCorpusFramework(contractHash) {
+export function corpusConfiguration(contractHash) {
     const fake = createFakeAdapter({
         model: contractHash === CORPUS_NONE_CLIENT_CONTRACT_HASH
             ? { ...CORPUS_MODEL, transactions: "none" }
@@ -251,12 +251,22 @@ export async function createCorpusFramework(contractHash) {
             ? {}
             : { transaction: failingCommit(fake.transaction) }),
     });
+    return {
+        config: {
+            api: CORPUS_ENTRYPOINT,
+            adapter,
+            resources: CORPUS_RESOURCES,
+            application: CORPUS_APPLICATION_CONFIG,
+            client: CORPUS_CLIENT_CONFIG,
+        },
+        adapterCalls: () => adapter.operations.length,
+    };
+}
+export async function createCorpusFramework(contractHash, prebuilt) {
+    const { config, adapterCalls } = corpusConfiguration(contractHash);
     const framework = await createFramework({
-        api: CORPUS_ENTRYPOINT,
-        adapter,
-        resources: CORPUS_RESOURCES,
-        application: CORPUS_APPLICATION_CONFIG,
-        client: CORPUS_CLIENT_CONFIG,
+        ...config,
+        ...(prebuilt === undefined ? {} : { prebuilt }),
     });
-    return { framework, adapterCalls: () => adapter.operations.length };
+    return { framework, adapterCalls };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/testing",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.4",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Conformance and extension testing utilities for Aventara.",
   "type": "module",
@@ -24,7 +24,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "1.0.0-rc.3"
+    "@aventara/core": "1.0.0-rc.4"
   },
   "publishConfig": {
     "access": "public"