zenstack 0.1.41 → 1.0.0

package/packages/internal/tests/query-processor.test.ts

@@ -0,0 +1,172 @@
+import {
+    FieldInfo,
+    PolicyOperationKind,
+    QueryContext,
+    type Service,
+} from '../src/types';
+import { QueryProcessor } from '../src/handler/data/query-processor';
+
+class MockService implements Service {
+    constructor(
+        private readonly fieldMapping: Record<string, Record<string, FieldInfo>>
+    ) {}
+
+    get db(): any {
+        throw new Error('Method not implemented.');
+    }
+
+    async resolveField(model: string, field: string) {
+        return this.fieldMapping[model]?.[field];
+    }
+
+    buildQueryGuard(
+        model: string,
+        operation: PolicyOperationKind,
+        context: QueryContext
+    ) {
+        return { [`${model}_${operation}`]: true };
+    }
+}
+
+describe('Query Processor Tests', () => {
+    it('arg processor', async () => {
+        const svc = new MockService({
+            List: {
+                todos: {
+                    type: 'Todo',
+                    isArray: true,
+                },
+            },
+            Todo: {
+                list: {
+                    type: 'List',
+                    isArray: false,
+                },
+            },
+        });
+
+        const processor = new QueryProcessor(svc);
+
+        // empty args
+        let r = await processor.processQueryArgs('List', {}, 'read', {});
+        expect(r).toEqual(
+            expect.objectContaining({ where: { List_read: true } })
+        );
+
+        // simple condition
+        r = await processor.processQueryArgs(
+            'List',
+            { where: { private: false } },
+            'read',
+            {}
+        );
+        expect(r).toEqual(
+            expect.objectContaining({
+                where: {
+                    AND: expect.arrayContaining([
+                        { private: false },
+                        { List_read: true },
+                    ]),
+                },
+            })
+        );
+
+        // include to-many
+        r = await processor.processQueryArgs(
+            'List',
+            { include: { todos: true } },
+            'read',
+            {}
+        );
+        expect(r).toEqual(
+            expect.objectContaining({
+                include: { todos: { where: { Todo_read: true } } },
+            })
+        );
+
+        // include to-many with condition
+        r = await processor.processQueryArgs(
+            'List',
+            { include: { haha: true, todos: { where: { private: false } } } },
+            'read',
+            {}
+        );
+        expect(r).toEqual(
+            expect.objectContaining({
+                include: {
+                    haha: true,
+                    todos: {
+                        where: {
+                            AND: expect.arrayContaining([
+                                { private: false },
+                                { Todo_read: true },
+                            ]),
+                        },
+                    },
+                },
+            })
+        );
+
+        // select to-many
+        r = await processor.processQueryArgs(
+            'List',
+            { select: { haha: true, todos: true } },
+            'read',
+            {}
+        );
+        expect(r).toEqual(
+            expect.objectContaining({
+                select: {
+                    haha: true,
+                    todos: {
+                        where: {
+                            Todo_read: true,
+                        },
+                    },
+                },
+            })
+        );
+
+        // select to-many with condition
+        r = await processor.processQueryArgs(
+            'List',
+            { select: { todos: { where: { private: false } } } },
+            'read',
+            {}
+        );
+        expect(r).toEqual(
+            expect.objectContaining({
+                select: {
+                    todos: {
+                        where: {
+                            AND: expect.arrayContaining([
+                                { private: false },
+                                { Todo_read: true },
+                            ]),
+                        },
+                    },
+                },
+            })
+        );
+
+        // include to-one, no processing
+        r = await processor.processQueryArgs(
+            'Todo',
+            { include: { list: true } },
+            'read',
+            {}
+        );
+        expect(r).toEqual(expect.objectContaining({ include: { list: true } }));
+
+        // select to-one, "id" is injected
+        r = await processor.processQueryArgs(
+            'Todo',
+            { select: { list: true } },
+            'read',
+            {}
+        );
+        expect(r).toEqual(
+            expect.objectContaining({ select: { id: true, list: true } })
+        );
+    });
+});

package/{out/cli/tsconfig.template.json → packages/internal/tsconfig.json}

@@ -6,12 +6,16 @@
         "sourceMap": true,
         "outDir": "lib",
         "strict": true,
+        "noUnusedLocals": true,
+        "noImplicitReturns": true,
         "moduleResolution": "node",
         "esModuleInterop": true,
         "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
         "declaration": true,
-        "resolveJsonModule": true
+        "resolveJsonModule": true,
+        "paths": {}
     },
-    "include": ["**/*.ts"],
-    "exclude": ["lib", ".prisma", "node_modules"]
+    "include": ["src/**/*.ts"],
+    "exclude": ["lib", "node_modules"]
 }

package/packages/runtime/auth.d.ts

@@ -0,0 +1 @@
+export * from '.zenstack/lib/auth';

package/packages/runtime/auth.js

@@ -0,0 +1,3 @@
+module.exports = {
+    ...require('.zenstack/lib/auth'),
+};

package/packages/runtime/hooks.d.ts

@@ -0,0 +1,10 @@
+import { ServerErrorCode } from '@zenstackhq/internal';
+
+export * from '.zenstack/lib/hooks';
+export type HooksError = {
+    status: number;
+    info: {
+        code: ServerErrorCode;
+        message: string;
+    };
+};

package/packages/runtime/hooks.js

@@ -0,0 +1,3 @@
+module.exports = {
+    ...require('.zenstack/lib/hooks'),
+};

package/packages/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export * from '.zenstack/lib';
+import service from '.zenstack/lib';
+export default service;

package/packages/runtime/index.js

@@ -0,0 +1 @@
+module.exports = require('.zenstack/lib').default;