@lit-protocol/vincent-ability-sdk 0.0.1-ea

package/dist/src/type-inference-verification/parameter-inference-tests-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-inference-tests-tool.d.ts","sourceRoot":"","sources":["../../../src/type-inference-verification/parameter-inference-tests-tool.ts"],"names":[],"mappings":"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"}

package/dist/src/type-inference-verification/parameter-inference-tests-tool.js

@@ -0,0 +1,537 @@
+"use strict";
+// src/type-inference-verification/parameter-inference-tests-ability.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testBasicParameterInference = testBasicParameterInference;
+exports.testPolicyResultInference = testPolicyResultInference;
+exports.testComplexDestructuring = testComplexDestructuring;
+exports.testAdvancedParameterValidation = testAdvancedParameterValidation;
+exports.testMissingTypes = testMissingTypes;
+/**
+ * Ability Parameter Type Inference Testing
+ *
+ * This file tests the TypeScript type inference for ability parameters,
+ * policy results, and context manipulation.
+ */
+const zod_1 = require("zod");
+const helpers_1 = require("../lib/abilityCore/helpers");
+const vincentAbility_1 = require("../lib/abilityCore/vincentAbility");
+const bundledPolicy_1 = require("../lib/policyCore/bundledPolicy/bundledPolicy");
+const vincentPolicy_1 = require("../lib/policyCore/vincentPolicy");
+// Define a schema for our test cases
+const testSchema = zod_1.z.object({
+    action: zod_1.z.string(),
+    target: zod_1.z.string(),
+    options: zod_1.z
+        .object({
+        priority: zod_1.z.number().optional(),
+        dryRun: zod_1.z.boolean().optional(),
+    })
+        .optional(),
+});
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Test Case 1: Basic parameter type inference
+ */
+function testBasicParameterInference() {
+    // Create a simple policy for testing
+    const basicParamInferPolicy = (0, vincentPolicy_1.createVincentPolicy)({
+        packageName: '@lit-protocol/test-policy@1.0.0',
+        abilityParamsSchema: zod_1.z.object({
+            operation: zod_1.z.string(),
+        }),
+        evalAllowResultSchema: zod_1.z.object({
+            allowed: zod_1.z.boolean(),
+        }),
+        evaluate: async (_, { allow }) => {
+            return allow({ allowed: true });
+        },
+    });
+    const testPolicy = (0, vincentPolicy_1.createVincentAbilityPolicy)({
+        abilityParamsSchema: testSchema,
+        bundledVincentPolicy: (0, bundledPolicy_1.asBundledVincentPolicy)(basicParamInferPolicy, '209oifusfdj'),
+        abilityParameterMappings: {
+            action: 'operation',
+        },
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/yesability3@1.0.0',
+        abilityDescription: 'Yes Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async ({ abilityParams }, { succeed }) => {
+            // Params should have the correct types
+            const { action, target, options } = abilityParams;
+            // String operations should work on string fields
+            action.toUpperCase();
+            target.toLowerCase();
+            // @ts-expect-error - Using number methods on string
+            action.toFixed(2);
+            // Optional field access should work
+            if (options) {
+                const { priority, dryRun } = options;
+                // Number operations should work if present
+                if (priority !== undefined) {
+                    priority.toFixed(2);
+                    // @ts-expect-error - Using string methods on number
+                    priority.toUpperCase();
+                }
+                // Boolean operations should work if present
+                if (dryRun !== undefined) {
+                    const isDry = dryRun === true;
+                    console.log(isDry);
+                    // @ts-expect-error - Using string methods on boolean
+                    dryRun.toUpperCase();
+                }
+            }
+            return succeed();
+        },
+        execute: async ({ abilityParams }, { succeed }) => {
+            // Same parameter validation in execute
+            const { action, target, options } = abilityParams;
+            console.log(target);
+            // String operations should work
+            action.toUpperCase();
+            // @ts-expect-error - Using array methods on string
+            action.push('new');
+            // Optional fields with correct types
+            if (options?.priority) {
+                options.priority.toFixed(2);
+            }
+            return succeed();
+        },
+    });
+}
+/**
+ * Test Case 2: Policy result type inference
+ */
+function testPolicyResultInference() {
+    // Create a policy with complex result type
+    const resultInferPolicy = (0, vincentPolicy_1.createVincentPolicy)({
+        packageName: '@lit-protocol/complex-policy@1.0.0',
+        abilityParamsSchema: zod_1.z.object({
+            command: zod_1.z.string(),
+        }),
+        evalAllowResultSchema: zod_1.z.object({
+            level: zod_1.z.enum(['low', 'medium', 'high']),
+            metadata: zod_1.z.object({
+                timestamp: zod_1.z.number(),
+                signature: zod_1.z.string(),
+            }),
+            flags: zod_1.z.array(zod_1.z.string()),
+        }),
+        evaluate: async (params, { allow }) => {
+            return allow({
+                level: 'medium',
+                metadata: {
+                    timestamp: Date.now(),
+                    signature: 'sig123',
+                },
+                flags: ['verbose', 'secure'],
+            });
+        },
+    });
+    const complexPolicy = (0, vincentPolicy_1.createVincentAbilityPolicy)({
+        abilityParamsSchema: testSchema,
+        bundledVincentPolicy: (0, bundledPolicy_1.asBundledVincentPolicy)(resultInferPolicy, '-0932i0fjs0jfd'),
+        abilityParameterMappings: {
+            action: 'command',
+        },
+    });
+    // Create policy with commit function
+    const commitResultPolicy = (0, vincentPolicy_1.createVincentPolicy)({
+        packageName: '@lit-protocol/commit-policy@1.0.0',
+        abilityParamsSchema: zod_1.z.object({
+            resource: zod_1.z.string(),
+        }),
+        evalAllowResultSchema: zod_1.z.object({
+            transactionId: zod_1.z.string(),
+        }),
+        commitParamsSchema: zod_1.z.object({
+            transactionId: zod_1.z.string(),
+            status: zod_1.z.enum(['complete', 'abort']),
+        }),
+        commitAllowResultSchema: zod_1.z.object({
+            success: zod_1.z.boolean(),
+            timestamp: zod_1.z.number(),
+        }),
+        evaluate: async (params, { allow }) => {
+            return allow({
+                transactionId: 'tx123',
+            });
+        },
+        commit: async (params, { allow }) => {
+            return allow({
+                success: params.status === 'complete',
+                timestamp: Date.now(),
+            });
+        },
+    });
+    const commitPolicy = (0, vincentPolicy_1.createVincentAbilityPolicy)({
+        abilityParamsSchema: testSchema,
+        bundledVincentPolicy: (0, bundledPolicy_1.asBundledVincentPolicy)(commitResultPolicy, '1098u2098qjfn'),
+        abilityParameterMappings: {
+            target: 'resource',
+        },
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/abilityPlusPlus@1.0.0',
+        abilityDescription: 'Plus Plus Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([complexPolicy, commitPolicy]),
+        precheck: async (params, { policiesContext, succeed }) => {
+            // Testing allow/deny branch type inference
+            if (policiesContext.allow) {
+                // When allowed, policy results should be accessible
+                if (policiesContext.allowedPolicies['@lit-protocol/complex-policy@1.0.0']) {
+                    const { level, metadata, flags } = policiesContext.allowedPolicies['@lit-protocol/complex-policy@1.0.0'].result;
+                    // Enum type should be correctly inferred
+                    switch (level) {
+                        case 'low':
+                        case 'medium':
+                        case 'high':
+                            break;
+                        // @ts-expect-error - Invalid enum value
+                        case 'invalid':
+                            break;
+                    }
+                    // Nested objects should be correctly typed
+                    const { timestamp, signature } = metadata;
+                    timestamp.toFixed(0);
+                    signature.toUpperCase();
+                    // @ts-expect-error - Using wrong method type
+                    timestamp.toUpperCase();
+                    // Arrays should be correctly typed
+                    flags.forEach((flag) => {
+                        flag.toUpperCase();
+                    });
+                    // @ts-expect-error - flags is string[], not number[]
+                    flags.map((flag) => flag.toFixed(2));
+                }
+                // @ts-expect-error - denyPolicyResult shouldn't exist when allowed
+                const denyResult = policiesContext.deniedPolicy;
+            }
+            else {
+                // When denied, denyPolicyResult should exist
+                const { packageName, result } = policiesContext.deniedPolicy;
+                console.log(packageName, result);
+            }
+            return succeed();
+        },
+        execute: async (params, { policiesContext, succeed }) => {
+            // Testing commit function type inference
+            if (policiesContext.allowedPolicies['@lit-protocol/commit-policy@1.0.0']) {
+                const { transactionId } = policiesContext.allowedPolicies['@lit-protocol/commit-policy@1.0.0'].result;
+                // Commit function should be correctly typed
+                const commitFn = policiesContext.allowedPolicies['@lit-protocol/commit-policy@1.0.0']?.commit;
+                // Valid commit parameters
+                const commitResult = await commitFn({
+                    transactionId,
+                    status: 'complete',
+                });
+                await commitFn({
+                    transactionId,
+                    // @ts-expect-error - Invalid enum value
+                    status: 'invalid',
+                });
+                // @ts-expect-error - Missing required parameter
+                await commitFn({
+                    transactionId,
+                });
+                // Result type checking
+                if (commitResult.allow) {
+                    const { success, timestamp } = commitResult.result;
+                    // Boolean operations
+                    const isSuccess = success === true;
+                    console.log(isSuccess);
+                    // Number operations
+                    timestamp.toFixed(0);
+                    // @ts-expect-error - Using wrong method
+                    success.toFixed(0);
+                }
+            }
+            return succeed();
+        },
+    });
+}
+/**
+ * Test Case 3: Complex destructuring and inference
+ */
+function testComplexDestructuring() {
+    // Create a simple policy
+    const complexDestructurePolicy = (0, vincentPolicy_1.createVincentPolicy)({
+        packageName: '@lit-protocol/test-policy@1.0.0',
+        abilityParamsSchema: zod_1.z.object({
+            action: zod_1.z.string(),
+        }),
+        evalAllowResultSchema: zod_1.z.object({
+            data: zod_1.z.any(),
+        }),
+        evaluate: async (params, { allow }) => {
+            return allow({ data: {} });
+        },
+    });
+    const testPolicy = (0, vincentPolicy_1.createVincentAbilityPolicy)({
+        abilityParamsSchema: testSchema,
+        bundledVincentPolicy: (0, bundledPolicy_1.asBundledVincentPolicy)(complexDestructurePolicy, '1-093iofijn209j'),
+        abilityParameterMappings: {
+            action: 'action',
+        },
+    });
+    // Define success and failure schemas
+    const successSchema = zod_1.z.object({
+        result: zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean(), zod_1.z.array(zod_1.z.string())]),
+        metadata: zod_1.z.record(zod_1.z.string()),
+    });
+    const failSchema = zod_1.z.object({
+        error: zod_1.z.object({
+            code: zod_1.z.number(),
+            message: zod_1.z.string(),
+        }),
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/abilityPlus@1.0.0',
+        abilityDescription: 'Plus Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeSuccessSchema: successSchema,
+        executeFailSchema: failSchema,
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        execute: async (params, { succeed, fail }) => {
+            // Validate that types are preserved through destructuring
+            // Check complex union type handling
+            succeed({
+                // String is valid in the union
+                result: 'string result',
+                metadata: { source: 'test' },
+            });
+            succeed({
+                // Number is valid in the union
+                result: 123,
+                metadata: { source: 'test' },
+            });
+            succeed({
+                // Array of strings is valid in the union
+                result: ['one', 'two', 'three'],
+                metadata: { source: 'test' },
+            });
+            succeed({
+                // @ts-expect-error - Object is not in the union
+                result: { key: 'value' },
+                metadata: { source: 'test' },
+            });
+            succeed({
+                // @ts-expect-error - Array of numbers is not in the union
+                result: [1, 2, 3],
+                metadata: { source: 'test' },
+            });
+            // Test complex nested object validation
+            fail({
+                error: {
+                    code: 500,
+                    message: 'Internal error',
+                },
+            });
+            fail({
+                error: {
+                    code: 400,
+                    message: 'Bad request',
+                },
+            });
+            fail({
+                error: {
+                    // @ts-expect-error - Wrong type for code
+                    code: '400', // Should be number
+                    message: 'Bad request',
+                },
+            });
+            fail({
+                // @ts-expect-error - Missing required message
+                error: {
+                    code: 400,
+                },
+            });
+            return succeed({
+                result: 'final result',
+                metadata: { status: 'complete' },
+            });
+        },
+    });
+}
+/**
+ * Test Case 4: Advanced parameter validation
+ */
+function testAdvancedParameterValidation() {
+    // Create a schema with complex types
+    const advancedSchema = zod_1.z.object({
+        action: zod_1.z.enum(['create', 'read', 'update', 'delete']),
+        target: zod_1.z.string().regex(/^[a-z0-9-]+$/),
+        data: zod_1.z
+            .union([
+            zod_1.z.object({ type: zod_1.z.literal('string'), value: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('number'), value: zod_1.z.number() }),
+            zod_1.z.object({ type: zod_1.z.literal('boolean'), value: zod_1.z.boolean() }),
+        ])
+            .optional(),
+        metadata: zod_1.z.record(zod_1.z.string()).optional(),
+    });
+    // Create a policy
+    const advancedParamPolicy = (0, vincentPolicy_1.createVincentPolicy)({
+        packageName: '@lit-protocol/test-policy@1.0.0',
+        abilityParamsSchema: zod_1.z.object({
+            op: zod_1.z.string(),
+        }),
+        evalAllowResultSchema: zod_1.z.boolean(),
+        evaluate: async (params, { allow }) => {
+            return allow(true);
+        },
+    });
+    const testPolicy = (0, vincentPolicy_1.createVincentAbilityPolicy)({
+        abilityParamsSchema: advancedSchema,
+        bundledVincentPolicy: (0, bundledPolicy_1.asBundledVincentPolicy)(advancedParamPolicy, '1-093iofijn209j'),
+        abilityParameterMappings: {
+            action: 'op',
+        },
+    });
+    return (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/plusplusability@1.0.0',
+        abilityDescription: 'Plus Plus Ability',
+        abilityParamsSchema: advancedSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        precheck: async ({ abilityParams }, { succeed }) => {
+            // Test enum type inference
+            const { action } = abilityParams;
+            // Valid enum values should be allowed
+            switch (action) {
+                case 'create':
+                case 'read':
+                case 'update':
+                case 'delete':
+                    break;
+                // @ts-expect-error - Invalid enum value
+                case 'invalid':
+                    break;
+            }
+            // Test discriminated union type inference
+            if (abilityParams.data) {
+                // TypeScript should narrow based on the 'type' field
+                switch (abilityParams.data.type) {
+                    case 'string':
+                        // Value should be a string when type is 'string'
+                        abilityParams.data.value.toUpperCase();
+                        // @ts-expect-error - Not a number operation
+                        abilityParams.data.value.toFixed(2);
+                        break;
+                    case 'number':
+                        // Value should be a number when type is 'number'
+                        abilityParams.data.value.toFixed(2);
+                        // @ts-expect-error - Not a string operation
+                        abilityParams.data.value.toUpperCase();
+                        break;
+                    case 'boolean': {
+                        // Value should be a boolean when type is 'boolean'
+                        const isTrue = abilityParams.data.value === true;
+                        console.log(isTrue);
+                        // @ts-expect-error - Not a string operation
+                        params.data.value.toUpperCase();
+                        break;
+                    }
+                }
+            }
+            return succeed();
+        },
+        execute: async ({ abilityParams }, { succeed }) => {
+            // Further test discriminated union handling
+            if (abilityParams.data) {
+                const { type, value } = abilityParams.data;
+                if (type === 'string') {
+                    // String operations
+                    value.includes('test');
+                }
+                else if (type === 'number') {
+                    // Number operations
+                    value.toFixed(2);
+                    // @ts-expect-error - Not available on number
+                    value.includes('test');
+                }
+                else if (type === 'boolean') {
+                    // Boolean operations
+                    const isFalse = !value;
+                    console.log(isFalse);
+                    // @ts-expect-error - Not available on boolean
+                    value.toFixed(2);
+                }
+            }
+            return succeed();
+        },
+    });
+}
+/**
+ * Test Case 5: Validating missing types cause errors
+ */
+function testMissingTypes() {
+    // Create a policy
+    const missingTypesPolicy = (0, vincentPolicy_1.createVincentPolicy)({
+        packageName: '@lit-protocol/test-policy@1.0.0',
+        abilityParamsSchema: zod_1.z.object({ op: zod_1.z.string() }),
+        evalAllowResultSchema: zod_1.z.object({ data: zod_1.z.string() }),
+        evaluate: async (_, { allow }) => {
+            return allow({ data: 'test' });
+        },
+    });
+    const testPolicy = (0, vincentPolicy_1.createVincentAbilityPolicy)({
+        abilityParamsSchema: testSchema,
+        bundledVincentPolicy: (0, bundledPolicy_1.asBundledVincentPolicy)(missingTypesPolicy, '20198jfgnfj'),
+        abilityParameterMappings: { action: 'op' },
+    });
+    // Define result schema
+    const successSchema = zod_1.z.object({
+        result: zod_1.z.string(),
+    });
+    // Case where success schema is defined but fail schema is not
+    const abilityWithOnlySuccessSchema = (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/abilityofglory@1.0.0',
+        abilityDescription: 'Glory Ability',
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeSuccessSchema: successSchema,
+        precheck: async (_, { succeed }) => {
+            return succeed();
+        },
+        execute: async (_, { succeed, fail }) => {
+            // Should be able to succeed with schema
+            succeed({ result: 'test' });
+            // @ts-expect-error Can't return a string when no schema defined
+            fail('Error message');
+            // @ts-expect-error - Can't fail with an object when no fail schema defined
+            fail({ error: 'message' });
+            return succeed({ result: 'final' });
+        },
+    });
+    // Case with failSchema but no successSchema
+    const failSchema = zod_1.z.object({
+        error: zod_1.z.string(),
+    });
+    const abilityWithOnlyFailSchema = (0, vincentAbility_1.createVincentAbility)({
+        packageName: '@lit-protocol/lets-ability-this@1.0.0',
+        abilityDescription: "Let's Ability This",
+        abilityParamsSchema: testSchema,
+        supportedPolicies: (0, helpers_1.supportedPoliciesForAbility)([testPolicy]),
+        executeFailSchema: failSchema,
+        precheck: async (params, { succeed }) => {
+            return succeed();
+        },
+        execute: async (params, { succeed, fail }) => {
+            // Should be able to succeed with no args since no success schema
+            succeed();
+            // Should be able to fail with schema
+            fail({ error: 'test error' });
+            // @ts-expect-error - Can't succeed with an object when no success schema defined
+            succeed({ result: 'success' });
+            return succeed();
+        },
+    });
+    return { abilityWithOnlySuccessSchema, abilityWithOnlyFailSchema };
+}
+//# sourceMappingURL=parameter-inference-tests-tool.js.map

package/dist/src/type-inference-verification/parameter-inference-tests-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-inference-tests-tool.js","sourceRoot":"","sources":["../../../src/type-inference-verification/parameter-inference-tests-tool.ts"],"names":[],"mappings":"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"}