@objectstack/spec 0.8.2 → 0.9.1

package/dist/qa/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Quality Assurance (QA) Protocol
+ *
+ * Defines how business logic and metadata are tested.
+ * Includes:
+ * - Test Scenarios
+ * - Test Cases
+ * - Expected Outcomes
+ */
+export * from './testing.zod';
+//# sourceMappingURL=index.d.ts.map

package/dist/qa/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/qa/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,eAAe,CAAC"}

package/dist/qa/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Quality Assurance (QA) Protocol
+ *
+ * Defines how business logic and metadata are tested.
+ * Includes:
+ * - Test Scenarios
+ * - Test Cases
+ * - Expected Outcomes
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./testing.zod"), exports);

package/dist/qa/testing.zod.d.ts

@@ -0,0 +1,345 @@
+import { z } from 'zod';
+export declare const TestContextSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const TestActionTypeSchema: z.ZodEnum<{
+    create_record: "create_record";
+    update_record: "update_record";
+    delete_record: "delete_record";
+    read_record: "read_record";
+    query_records: "query_records";
+    api_call: "api_call";
+    run_script: "run_script";
+    wait: "wait";
+}>;
+export declare const TestActionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        create_record: "create_record";
+        update_record: "update_record";
+        delete_record: "delete_record";
+        read_record: "read_record";
+        query_records: "query_records";
+        api_call: "api_call";
+        run_script: "run_script";
+        wait: "wait";
+    }>;
+    target: z.ZodString;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TestAssertionTypeSchema: z.ZodEnum<{
+    error: "error";
+    lt: "lt";
+    lte: "lte";
+    gt: "gt";
+    gte: "gte";
+    equals: "equals";
+    not_equals: "not_equals";
+    contains: "contains";
+    not_contains: "not_contains";
+    is_null: "is_null";
+    not_null: "not_null";
+}>;
+export declare const TestAssertionSchema: z.ZodObject<{
+    field: z.ZodString;
+    operator: z.ZodEnum<{
+        error: "error";
+        lt: "lt";
+        lte: "lte";
+        gt: "gt";
+        gte: "gte";
+        equals: "equals";
+        not_equals: "not_equals";
+        contains: "contains";
+        not_contains: "not_contains";
+        is_null: "is_null";
+        not_null: "not_null";
+    }>;
+    expectedValue: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const TestStepSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    action: z.ZodObject<{
+        type: z.ZodEnum<{
+            create_record: "create_record";
+            update_record: "update_record";
+            delete_record: "delete_record";
+            read_record: "read_record";
+            query_records: "query_records";
+            api_call: "api_call";
+            run_script: "run_script";
+            wait: "wait";
+        }>;
+        target: z.ZodString;
+        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        user: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        operator: z.ZodEnum<{
+            error: "error";
+            lt: "lt";
+            lte: "lte";
+            gt: "gt";
+            gte: "gte";
+            equals: "equals";
+            not_equals: "not_equals";
+            contains: "contains";
+            not_contains: "not_contains";
+            is_null: "is_null";
+            not_null: "not_null";
+        }>;
+        expectedValue: z.ZodUnknown;
+    }, z.core.$strip>>>;
+    capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const TestScenarioSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    setup: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        action: z.ZodObject<{
+            type: z.ZodEnum<{
+                create_record: "create_record";
+                update_record: "update_record";
+                delete_record: "delete_record";
+                read_record: "read_record";
+                query_records: "query_records";
+                api_call: "api_call";
+                run_script: "run_script";
+                wait: "wait";
+            }>;
+            target: z.ZodString;
+            payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            user: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                error: "error";
+                lt: "lt";
+                lte: "lte";
+                gt: "gt";
+                gte: "gte";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                is_null: "is_null";
+                not_null: "not_null";
+            }>;
+            expectedValue: z.ZodUnknown;
+        }, z.core.$strip>>>;
+        capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>>;
+    steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        action: z.ZodObject<{
+            type: z.ZodEnum<{
+                create_record: "create_record";
+                update_record: "update_record";
+                delete_record: "delete_record";
+                read_record: "read_record";
+                query_records: "query_records";
+                api_call: "api_call";
+                run_script: "run_script";
+                wait: "wait";
+            }>;
+            target: z.ZodString;
+            payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            user: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                error: "error";
+                lt: "lt";
+                lte: "lte";
+                gt: "gt";
+                gte: "gte";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                is_null: "is_null";
+                not_null: "not_null";
+            }>;
+            expectedValue: z.ZodUnknown;
+        }, z.core.$strip>>>;
+        capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    teardown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        action: z.ZodObject<{
+            type: z.ZodEnum<{
+                create_record: "create_record";
+                update_record: "update_record";
+                delete_record: "delete_record";
+                read_record: "read_record";
+                query_records: "query_records";
+                api_call: "api_call";
+                run_script: "run_script";
+                wait: "wait";
+            }>;
+            target: z.ZodString;
+            payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            user: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            operator: z.ZodEnum<{
+                error: "error";
+                lt: "lt";
+                lte: "lte";
+                gt: "gt";
+                gte: "gte";
+                equals: "equals";
+                not_equals: "not_equals";
+                contains: "contains";
+                not_contains: "not_contains";
+                is_null: "is_null";
+                not_null: "not_null";
+            }>;
+            expectedValue: z.ZodUnknown;
+        }, z.core.$strip>>>;
+        capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>>;
+    requires: z.ZodOptional<z.ZodObject<{
+        params: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TestSuiteSchema: z.ZodObject<{
+    name: z.ZodString;
+    scenarios: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        setup: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            action: z.ZodObject<{
+                type: z.ZodEnum<{
+                    create_record: "create_record";
+                    update_record: "update_record";
+                    delete_record: "delete_record";
+                    read_record: "read_record";
+                    query_records: "query_records";
+                    api_call: "api_call";
+                    run_script: "run_script";
+                    wait: "wait";
+                }>;
+                target: z.ZodString;
+                payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                user: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    error: "error";
+                    lt: "lt";
+                    lte: "lte";
+                    gt: "gt";
+                    gte: "gte";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    is_null: "is_null";
+                    not_null: "not_null";
+                }>;
+                expectedValue: z.ZodUnknown;
+            }, z.core.$strip>>>;
+            capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>>;
+        steps: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            action: z.ZodObject<{
+                type: z.ZodEnum<{
+                    create_record: "create_record";
+                    update_record: "update_record";
+                    delete_record: "delete_record";
+                    read_record: "read_record";
+                    query_records: "query_records";
+                    api_call: "api_call";
+                    run_script: "run_script";
+                    wait: "wait";
+                }>;
+                target: z.ZodString;
+                payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                user: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    error: "error";
+                    lt: "lt";
+                    lte: "lte";
+                    gt: "gt";
+                    gte: "gte";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    is_null: "is_null";
+                    not_null: "not_null";
+                }>;
+                expectedValue: z.ZodUnknown;
+            }, z.core.$strip>>>;
+            capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        teardown: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            action: z.ZodObject<{
+                type: z.ZodEnum<{
+                    create_record: "create_record";
+                    update_record: "update_record";
+                    delete_record: "delete_record";
+                    read_record: "read_record";
+                    query_records: "query_records";
+                    api_call: "api_call";
+                    run_script: "run_script";
+                    wait: "wait";
+                }>;
+                target: z.ZodString;
+                payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                user: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            assertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<{
+                    error: "error";
+                    lt: "lt";
+                    lte: "lte";
+                    gt: "gt";
+                    gte: "gte";
+                    equals: "equals";
+                    not_equals: "not_equals";
+                    contains: "contains";
+                    not_contains: "not_contains";
+                    is_null: "is_null";
+                    not_null: "not_null";
+                }>;
+                expectedValue: z.ZodUnknown;
+            }, z.core.$strip>>>;
+            capture: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>>;
+        requires: z.ZodOptional<z.ZodObject<{
+            params: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TestSuite = z.infer<typeof TestSuiteSchema>;
+export type TestScenario = z.infer<typeof TestScenarioSchema>;
+export type TestStep = z.infer<typeof TestStepSchema>;
+export type TestAction = z.infer<typeof TestActionSchema>;
+export type TestAssertion = z.infer<typeof TestAssertionSchema>;
+//# sourceMappingURL=testing.zod.d.ts.map

package/dist/qa/testing.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.zod.d.ts","sourceRoot":"","sources":["../../src/qa/testing.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,iBAAiB,wCAA0F,CAAC;AAGzH,eAAO,MAAM,oBAAoB;;;;;;;;;EAS/B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;iBAK3B,CAAC;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;EAYlC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAI9B,CAAC;AAIH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAe7B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/qa/testing.zod.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSuiteSchema = exports.TestScenarioSchema = exports.TestStepSchema = exports.TestAssertionSchema = exports.TestAssertionTypeSchema = exports.TestActionSchema = exports.TestActionTypeSchema = exports.TestContextSchema = void 0;
+const zod_1 = require("zod");
+// --- Building Blocks ---
+exports.TestContextSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).describe('Initial context or variables for the test');
+// Action Types
+exports.TestActionTypeSchema = zod_1.z.enum([
+    'create_record',
+    'update_record',
+    'delete_record',
+    'read_record',
+    'query_records',
+    'api_call',
+    'run_script',
+    'wait' // Testing async processes
+]);
+exports.TestActionSchema = zod_1.z.object({
+    type: exports.TestActionTypeSchema,
+    target: zod_1.z.string().describe('Target Object, API Endpoint, or Function Name'),
+    payload: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional().describe('Data to send or use'),
+    user: zod_1.z.string().optional().describe('Run as specific user/role') // Impersonation
+});
+// Assertion Types
+exports.TestAssertionTypeSchema = zod_1.z.enum([
+    'equals',
+    'not_equals',
+    'contains',
+    'not_contains',
+    'is_null',
+    'not_null',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'error' // Expecting an error
+]);
+exports.TestAssertionSchema = zod_1.z.object({
+    field: zod_1.z.string().describe('Field path in the result to check (e.g. "body.data.0.status")'),
+    operator: exports.TestAssertionTypeSchema,
+    expectedValue: zod_1.z.unknown()
+});
+// --- Test Structure ---
+exports.TestStepSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    action: exports.TestActionSchema,
+    assertions: zod_1.z.array(exports.TestAssertionSchema).optional(),
+    // Capture outputs to variables for subsequent steps
+    capture: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional().describe('Map result fields to context variables: { "newId": "body._id" }')
+});
+exports.TestScenarioSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    tags: zod_1.z.array(zod_1.z.string()).optional(), // e.g. "critical", "regression", "crm"
+    setup: zod_1.z.array(exports.TestStepSchema).optional().describe('Steps to run before main test'),
+    steps: zod_1.z.array(exports.TestStepSchema).describe('Main test sequence'),
+    teardown: zod_1.z.array(exports.TestStepSchema).optional().describe('Steps to cleanup'),
+    // Environment requirements
+    requires: zod_1.z.object({
+        params: zod_1.z.array(zod_1.z.string()).optional(), // Required env vars or params
+        plugins: zod_1.z.array(zod_1.z.string()).optional()
+    }).optional()
+});
+exports.TestSuiteSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    scenarios: zod_1.z.array(exports.TestScenarioSchema)
+});