@askdb/core 0.5.0-beta.12 → 0.5.0-beta.14

package/dist/schema/v2/tenant-policy.d.ts

@@ -0,0 +1,715 @@
+import { z } from "zod";
+export declare const tenantRootSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantIdColumn: z.ZodString;
+    label: z.ZodString;
+    parent: z.ZodOptional<z.ZodObject<{
+        root: z.ZodString;
+        foreignKey: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        root: string;
+        foreignKey: string;
+    }, {
+        root: string;
+        foreignKey: string;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    tenantIdColumn: string;
+    parent?: {
+        root: string;
+        foreignKey: string;
+    } | undefined;
+}, {
+    id: string;
+    label: string;
+    tenantIdColumn: string;
+    parent?: {
+        root: string;
+        foreignKey: string;
+    } | undefined;
+}>;
+export declare const hierarchyEdgeSchema: z.ZodObject<{
+    parent: z.ZodString;
+    child: z.ZodString;
+    foreignKey: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    foreignKey: string;
+    parent: string;
+    child: string;
+}, {
+    foreignKey: string;
+    parent: string;
+    child: string;
+}>;
+declare const scopeThroughSchema: z.ZodUnion<[z.ZodObject<{
+    root: z.ZodString;
+    column: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    root: string;
+    column: string;
+}, {
+    root: string;
+    column: string;
+}>, z.ZodObject<{
+    root: z.ZodString;
+    join: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        from: string;
+        to: string;
+    }, {
+        from: string;
+        to: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    join: {
+        from: string;
+        to: string;
+    }[];
+    root: string;
+}, {
+    join: {
+        from: string;
+        to: string;
+    }[];
+    root: string;
+}>]>;
+export declare const scopedTableSchema: z.ZodObject<{
+    id: z.ZodString;
+    scopeThrough: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        root: z.ZodString;
+        column: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        root: string;
+        column: string;
+    }, {
+        root: string;
+        column: string;
+    }>, z.ZodObject<{
+        root: z.ZodString;
+        join: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            from: string;
+            to: string;
+        }, {
+            from: string;
+            to: string;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        join: {
+            from: string;
+            to: string;
+        }[];
+        root: string;
+    }, {
+        join: {
+            from: string;
+            to: string;
+        }[];
+        root: string;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    scopeThrough: ({
+        root: string;
+        column: string;
+    } | {
+        join: {
+            from: string;
+            to: string;
+        }[];
+        root: string;
+    })[];
+}, {
+    id: string;
+    scopeThrough: ({
+        root: string;
+        column: string;
+    } | {
+        join: {
+            from: string;
+            to: string;
+        }[];
+        root: string;
+    })[];
+}>;
+export declare const polymorphicTableSchema: z.ZodObject<{
+    id: z.ZodString;
+    typeColumn: z.ZodString;
+    idColumn: z.ZodString;
+    mapping: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    typeColumn: string;
+    idColumn: string;
+    mapping: Record<string, string>;
+}, {
+    id: string;
+    typeColumn: string;
+    idColumn: string;
+    mapping: Record<string, string>;
+}>;
+export declare const enforcementModeSchema: z.ZodEnum<["strict", "warn"]>;
+export declare const tenantPolicyFrontmatterSchema: z.ZodObject<{
+    schemaId: z.ZodString;
+    enforcement: z.ZodEnum<["strict", "warn"]>;
+    roots: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantIdColumn: z.ZodString;
+        label: z.ZodString;
+        parent: z.ZodOptional<z.ZodObject<{
+            root: z.ZodString;
+            foreignKey: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            root: string;
+            foreignKey: string;
+        }, {
+            root: string;
+            foreignKey: string;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        label: string;
+        tenantIdColumn: string;
+        parent?: {
+            root: string;
+            foreignKey: string;
+        } | undefined;
+    }, {
+        id: string;
+        label: string;
+        tenantIdColumn: string;
+        parent?: {
+            root: string;
+            foreignKey: string;
+        } | undefined;
+    }>, "many">;
+    hierarchy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        parent: z.ZodString;
+        child: z.ZodString;
+        foreignKey: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        foreignKey: string;
+        parent: string;
+        child: string;
+    }, {
+        foreignKey: string;
+        parent: string;
+        child: string;
+    }>, "many">>;
+    scopedTables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        scopeThrough: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            root: z.ZodString;
+            column: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            root: string;
+            column: string;
+        }, {
+            root: string;
+            column: string;
+        }>, z.ZodObject<{
+            root: z.ZodString;
+            join: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                from: string;
+                to: string;
+            }, {
+                from: string;
+                to: string;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            join: {
+                from: string;
+                to: string;
+            }[];
+            root: string;
+        }, {
+            join: {
+                from: string;
+                to: string;
+            }[];
+            root: string;
+        }>]>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        scopeThrough: ({
+            root: string;
+            column: string;
+        } | {
+            join: {
+                from: string;
+                to: string;
+            }[];
+            root: string;
+        })[];
+    }, {
+        id: string;
+        scopeThrough: ({
+            root: string;
+            column: string;
+        } | {
+            join: {
+                from: string;
+                to: string;
+            }[];
+            root: string;
+        })[];
+    }>, "many">>;
+    polymorphicTables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        typeColumn: z.ZodString;
+        idColumn: z.ZodString;
+        mapping: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        typeColumn: string;
+        idColumn: string;
+        mapping: Record<string, string>;
+    }, {
+        id: string;
+        typeColumn: string;
+        idColumn: string;
+        mapping: Record<string, string>;
+    }>, "many">>;
+    globalTables: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    schemaId: string;
+    enforcement: "strict" | "warn";
+    roots: {
+        id: string;
+        label: string;
+        tenantIdColumn: string;
+        parent?: {
+            root: string;
+            foreignKey: string;
+        } | undefined;
+    }[];
+    hierarchy?: {
+        foreignKey: string;
+        parent: string;
+        child: string;
+    }[] | undefined;
+    scopedTables?: {
+        id: string;
+        scopeThrough: ({
+            root: string;
+            column: string;
+        } | {
+            join: {
+                from: string;
+                to: string;
+            }[];
+            root: string;
+        })[];
+    }[] | undefined;
+    polymorphicTables?: {
+        id: string;
+        typeColumn: string;
+        idColumn: string;
+        mapping: Record<string, string>;
+    }[] | undefined;
+    globalTables?: string[] | undefined;
+}, {
+    schemaId: string;
+    enforcement: "strict" | "warn";
+    roots: {
+        id: string;
+        label: string;
+        tenantIdColumn: string;
+        parent?: {
+            root: string;
+            foreignKey: string;
+        } | undefined;
+    }[];
+    hierarchy?: {
+        foreignKey: string;
+        parent: string;
+        child: string;
+    }[] | undefined;
+    scopedTables?: {
+        id: string;
+        scopeThrough: ({
+            root: string;
+            column: string;
+        } | {
+            join: {
+                from: string;
+                to: string;
+            }[];
+            root: string;
+        })[];
+    }[] | undefined;
+    polymorphicTables?: {
+        id: string;
+        typeColumn: string;
+        idColumn: string;
+        mapping: Record<string, string>;
+    }[] | undefined;
+    globalTables?: string[] | undefined;
+}>;
+export type TenantRoot = z.infer<typeof tenantRootSchema>;
+export type HierarchyEdge = z.infer<typeof hierarchyEdgeSchema>;
+export type ScopeThrough = z.infer<typeof scopeThroughSchema>;
+export type ScopedTable = z.infer<typeof scopedTableSchema>;
+export type PolymorphicTable = z.infer<typeof polymorphicTableSchema>;
+export type EnforcementMode = z.infer<typeof enforcementModeSchema>;
+export type TenantPolicyFrontmatter = z.infer<typeof tenantPolicyFrontmatterSchema>;
+export declare const TENANT_POLICY_H2_SECTIONS: readonly ["Hierarchy", "Scope rules", "Sensitive interactions"];
+export type TenantPolicyH2Section = (typeof TENANT_POLICY_H2_SECTIONS)[number];
+export type ParsedTenantPolicyMarkdown = {
+    frontmatter: TenantPolicyFrontmatter;
+    body: string;
+    sections: Partial<Record<TenantPolicyH2Section, string>>;
+};
+export type TenantAccessIds = {
+    kind: "ids";
+    tenantRoot: string;
+    ids: string[];
+};
+export type TenantAccessSubtree = {
+    kind: "subtree";
+    tenantRoot: string;
+    rootIds: string[];
+    includeDescendants: true;
+};
+export type TenantAccessMultiRoot = {
+    kind: "multi_root";
+    scopes: Array<{
+        tenantRoot: string;
+        ids: string[];
+    }>;
+};
+export type TenantAccessGlobal = {
+    kind: "global";
+    reason: string;
+};
+export type TenantAccess = TenantAccessIds | TenantAccessSubtree | TenantAccessMultiRoot | TenantAccessGlobal;
+export type TenantFilterCondition = {
+    column: string;
+    operator: "=" | "IN" | "!=" | "NOT IN";
+    value: string | string[];
+};
+export type TenantFilter = {
+    conditions: TenantFilterCondition[];
+};
+export type TenantScopeContext = {
+    role?: string;
+    label?: string;
+    department?: string;
+    region?: string;
+    attributes?: Record<string, string>;
+    description?: string;
+};
+export type TenantScope = {
+    access: TenantAccess;
+    tenantFilters?: Record<string, TenantFilter>;
+    context?: TenantScopeContext;
+};
+export declare const tenantAccessSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"ids">;
+    tenantRoot: z.ZodString;
+    ids: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    ids: string[];
+    kind: "ids";
+    tenantRoot: string;
+}, {
+    ids: string[];
+    kind: "ids";
+    tenantRoot: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"subtree">;
+    tenantRoot: z.ZodString;
+    rootIds: z.ZodArray<z.ZodString, "many">;
+    includeDescendants: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    kind: "subtree";
+    tenantRoot: string;
+    rootIds: string[];
+    includeDescendants: true;
+}, {
+    kind: "subtree";
+    tenantRoot: string;
+    rootIds: string[];
+    includeDescendants: true;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"multi_root">;
+    scopes: z.ZodArray<z.ZodObject<{
+        tenantRoot: z.ZodString;
+        ids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        ids: string[];
+        tenantRoot: string;
+    }, {
+        ids: string[];
+        tenantRoot: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    kind: "multi_root";
+    scopes: {
+        ids: string[];
+        tenantRoot: string;
+    }[];
+}, {
+    kind: "multi_root";
+    scopes: {
+        ids: string[];
+        tenantRoot: string;
+    }[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"global">;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "global";
+    reason: string;
+}, {
+    kind: "global";
+    reason: string;
+}>]>;
+export declare const tenantScopeSchema: z.ZodObject<{
+    access: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"ids">;
+        tenantRoot: z.ZodString;
+        ids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        ids: string[];
+        kind: "ids";
+        tenantRoot: string;
+    }, {
+        ids: string[];
+        kind: "ids";
+        tenantRoot: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"subtree">;
+        tenantRoot: z.ZodString;
+        rootIds: z.ZodArray<z.ZodString, "many">;
+        includeDescendants: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "subtree";
+        tenantRoot: string;
+        rootIds: string[];
+        includeDescendants: true;
+    }, {
+        kind: "subtree";
+        tenantRoot: string;
+        rootIds: string[];
+        includeDescendants: true;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"multi_root">;
+        scopes: z.ZodArray<z.ZodObject<{
+            tenantRoot: z.ZodString;
+            ids: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            ids: string[];
+            tenantRoot: string;
+        }, {
+            ids: string[];
+            tenantRoot: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "multi_root";
+        scopes: {
+            ids: string[];
+            tenantRoot: string;
+        }[];
+    }, {
+        kind: "multi_root";
+        scopes: {
+            ids: string[];
+            tenantRoot: string;
+        }[];
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"global">;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "global";
+        reason: string;
+    }, {
+        kind: "global";
+        reason: string;
+    }>]>;
+    tenantFilters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        conditions: z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            operator: z.ZodEnum<["=", "IN", "!=", "NOT IN"]>;
+            value: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+        }, "strip", z.ZodTypeAny, {
+            value: string | string[];
+            column: string;
+            operator: "=" | "IN" | "!=" | "NOT IN";
+        }, {
+            value: string | string[];
+            column: string;
+            operator: "=" | "IN" | "!=" | "NOT IN";
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        conditions: {
+            value: string | string[];
+            column: string;
+            operator: "=" | "IN" | "!=" | "NOT IN";
+        }[];
+    }, {
+        conditions: {
+            value: string | string[];
+            column: string;
+            operator: "=" | "IN" | "!=" | "NOT IN";
+        }[];
+    }>>>;
+    context: z.ZodOptional<z.ZodObject<{
+        role: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        department: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        description?: string | undefined;
+        label?: string | undefined;
+        role?: string | undefined;
+        department?: string | undefined;
+        region?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    }, {
+        description?: string | undefined;
+        label?: string | undefined;
+        role?: string | undefined;
+        department?: string | undefined;
+        region?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    access: {
+        ids: string[];
+        kind: "ids";
+        tenantRoot: string;
+    } | {
+        kind: "subtree";
+        tenantRoot: string;
+        rootIds: string[];
+        includeDescendants: true;
+    } | {
+        kind: "multi_root";
+        scopes: {
+            ids: string[];
+            tenantRoot: string;
+        }[];
+    } | {
+        kind: "global";
+        reason: string;
+    };
+    tenantFilters?: Record<string, {
+        conditions: {
+            value: string | string[];
+            column: string;
+            operator: "=" | "IN" | "!=" | "NOT IN";
+        }[];
+    }> | undefined;
+    context?: {
+        description?: string | undefined;
+        label?: string | undefined;
+        role?: string | undefined;
+        department?: string | undefined;
+        region?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    } | undefined;
+}, {
+    access: {
+        ids: string[];
+        kind: "ids";
+        tenantRoot: string;
+    } | {
+        kind: "subtree";
+        tenantRoot: string;
+        rootIds: string[];
+        includeDescendants: true;
+    } | {
+        kind: "multi_root";
+        scopes: {
+            ids: string[];
+            tenantRoot: string;
+        }[];
+    } | {
+        kind: "global";
+        reason: string;
+    };
+    tenantFilters?: Record<string, {
+        conditions: {
+            value: string | string[];
+            column: string;
+            operator: "=" | "IN" | "!=" | "NOT IN";
+        }[];
+    }> | undefined;
+    context?: {
+        description?: string | undefined;
+        label?: string | undefined;
+        role?: string | undefined;
+        department?: string | undefined;
+        region?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    } | undefined;
+}>;
+export type TableTenantClassification = "scoped" | "inherited" | "polymorphic" | "global" | "root" | "unknown";
+export type TableCoverageEntry = {
+    tableId: string;
+    classification: TableTenantClassification;
+    scopeRoots?: string[];
+};
+export type TenantPolicyWarning = {
+    kind: "orphaned_root_id";
+    id: string;
+} | {
+    kind: "orphaned_column_id";
+    id: string;
+    context: string;
+} | {
+    kind: "orphaned_scoped_table_id";
+    id: string;
+} | {
+    kind: "orphaned_polymorphic_table_id";
+    id: string;
+} | {
+    kind: "orphaned_global_table_id";
+    id: string;
+} | {
+    kind: "orphaned_fk_id";
+    id: string;
+    context: string;
+} | {
+    kind: "hierarchy_cycle";
+    ids: string[];
+} | {
+    kind: "unknown_root_in_scope";
+    id: string;
+    context: string;
+} | {
+    kind: "unknown_root_in_hierarchy";
+    id: string;
+    context: string;
+} | {
+    kind: "unknown_root_in_mapping";
+    id: string;
+    context: string;
+};
+export type NormalizedTenantPolicy = {
+    schemaId: string;
+    enforcement: EnforcementMode;
+    roots: TenantRoot[];
+    hierarchy: HierarchyEdge[];
+    scopedTables: ScopedTable[];
+    polymorphicTables: PolymorphicTable[];
+    globalTables: string[];
+    coverage: TableCoverageEntry[];
+    warnings: TenantPolicyWarning[];
+    body: string;
+    sections: Partial<Record<TenantPolicyH2Section, string>>;
+};
+export {};
+//# sourceMappingURL=tenant-policy.d.ts.map