@snowtop/ent 0.2.9 → 0.2.10

package/core/ent.js

@@ -133,12 +133,15 @@ function createAssocEdgeConfigLoader(options) {
         if (!ids.length) {
             return [];
         }
+        // DataLoader exposes readonly batch keys; clone once so downstream query helpers
+        // can keep their mutable-array signatures.
+        const keys = [...ids];
         let col = options.key;
         // defaults to uuid
         let typ = options.keyType || "uuid";
         const rowOptions = {
             ...options,
-            clause: clause.DBTypeIn(col, ids, typ),
+            clause: clause.DBTypeIn(col, keys, typ),
         };
         // TODO is there a better way of doing this?
         // context not needed because we're creating a loader which has its own cache which is being used here
@@ -150,7 +153,7 @@ function createAssocEdgeConfigLoader(options) {
                 rowMap.set(key, node);
             }
         }
-        return ids.map((id) => rowMap.get(id) ?? null);
+        return keys.map((id) => rowMap.get(id) ?? null);
     }, loaderOptions, options.tableName);
 }
 // used to wrap errors that would eventually be thrown in ents
@@ -185,8 +188,9 @@ function createEntLoader(viewer, options, map) {
         if (!ids.length) {
             return [];
         }
+        const keys = [...ids];
         const loader = options.loaderFactory.createLoader(viewer.context);
-        const rows = await loader.loadMany(ids);
+        const rows = await loader.loadMany(keys);
         // this is a loader which should return the same order based on passed-in ids
         // so let's depend on that...
         return (0, async_utils_1.mapWithConcurrency)(rows, getEntLoaderPrivacyConcurrencyLimit(), async (row, idx) => {
@@ -200,9 +204,9 @@ function createEntLoader(viewer, options, map) {
             }
             if (!row) {
                 if (tableName) {
-                    return new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]} in table ${tableName}`));
+                    return new ErrorWrapper(new Error(`couldn't find row for value ${keys[idx]} in table ${tableName}`));
                 }
-                return new ErrorWrapper(new Error(`couldn't find row for value ${ids[idx]}`));
+                return new ErrorWrapper(new Error(`couldn't find row for value ${keys[idx]}`));
             }
             const r = await applyPrivacyPolicyForRowImpl(viewer, options, row);
             if (rowIsError(r)) {

package/core/extensions.d.ts

@@ -1,5 +1,4 @@
-import { type Pool } from "pg";
-import type { RuntimeDBExtension } from "./config";
+import type { PostgresDriver, RuntimeDBExtension } from "./config";
 import type { ResolvedDevSchema } from "./dev_schema";
 export interface InstalledDBExtension {
     name: string;
@@ -16,10 +15,16 @@ export interface ExtensionRuntimeHandler {
     types?: ExtensionTypeParser[];
     validate?(installed: InstalledDBExtension, extension: RuntimeDBExtension): void | Promise<void>;
 }
+interface Queryable {
+    query<R extends Record<string, any> = any>(query: string, values?: any[]): Promise<{
+        rows: R[];
+    }>;
+}
 export declare function registerExtensionRuntime(handler: ExtensionRuntimeHandler): void;
 export declare function clearExtensionRuntimes(): void;
 export declare function normalizeExtensions(extensions: RuntimeDBExtension[]): RuntimeDBExtension[];
 export declare function resolveExtensions(cfg?: RuntimeDBExtension[]): RuntimeDBExtension[];
 export declare function getExtensionSearchPathSchemas(extensions: RuntimeDBExtension[]): string[];
 export declare function buildExtensionSearchPath(resolvedDevSchema: ResolvedDevSchema, extensions: RuntimeDBExtension[]): string | undefined;
-export declare function initializeExtensions(pool: Pick<Pool, "query">, extensions: RuntimeDBExtension[]): Promise<void>;
+export declare function initializeExtensions(pool: Queryable, extensions: RuntimeDBExtension[], postgresDriver?: PostgresDriver): Promise<void>;
+export {};

package/core/extensions.js

@@ -197,7 +197,7 @@ async function initializeRegisteredTypeParsers(pool, configuredExtensions) {
         registerArrayParser(row.typarray, typeHandler.parse);
     }
 }
-async function initializeExtensions(pool, extensions) {
+async function initializeExtensions(pool, extensions, postgresDriver = "pg") {
     const normalizedExtensions = normalizeExtensions(extensions);
     const configuredExtensions = new Map(normalizedExtensions.map((extension) => [extension.name, extension]));
     const installedExtensions = await getInstalledExtensions(pool, normalizedExtensions);
@@ -216,5 +216,14 @@ async function initializeExtensions(pool, extensions) {
         const handler = runtimeHandlers.get(extension.name);
         await handler?.validate?.(installed, extension);
     }
+    if (postgresDriver === "bun") {
+        const unsupportedExtensions = normalizedExtensions
+            .filter((extension) => (runtimeHandlers.get(extension.name)?.types || []).length > 0)
+            .map((extension) => extension.name);
+        if (unsupportedExtensions.length > 0) {
+            throw new Error(`postgresDriver "bun" does not support extension runtime type parsers for: ${unsupportedExtensions.join(", ")}`);
+        }
+        return;
+    }
     await initializeRegisteredTypeParsers(pool, configuredExtensions);
 }

package/core/global_schema.js

@@ -23,7 +23,7 @@ function isGlobalSchemaField(f) {
 function setGlobalSchema(val) {
     globalSchema = val;
     if (val.fields) {
-        for (const [k, v] of Object.entries(val.fields)) {
+        for (const [_k, v] of Object.entries(val.fields)) {
             if (isGlobalSchemaField(v) && v.type.type) {
                 globalSchemaFields.set(v.type.type, v);
             }

package/core/loaders/loader.d.ts

@@ -33,13 +33,13 @@ export declare class BoundedCacheMap<K, V> {
 }
 export declare function createBoundedCacheMap<K, V>(cacheMap: CacheMapLike<K, V>, cacheKeyFn?: CacheKeyFn<K>): CacheMapLike<K, V>;
 export declare function createLoaderCacheMap<K, V>(options: DataOptions): CacheMapLike<K, V>;
-export declare class CacheMap {
+export declare class CacheMap<K, V> implements CacheMapLike<K, V> {
     private options;
     private m;
     constructor(options: DataOptions);
-    get(key: any): any;
-    set(key: any, value: any): Map<any, any>;
-    delete(key: any): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V): Map<K, V>;
+    delete(key: K): boolean;
     clear(): void;
 }
 export {};

package/core/logger.js

@@ -26,18 +26,20 @@ function clearLogLevels() {
 }
 function log(level, msg) {
     if (logLevels.has(level)) {
+        const method = m[level];
         // mostly for sqlite error but fine for any type of error
         if (level == "error" && msg instanceof Error && msg.message !== undefined) {
             console.error(msg.message);
             return;
         }
         // console[m[level]](inspect(msg, false, 10));
-        console[m[level]](msg);
+        console[method](msg);
     }
 }
 function logIf(level, logFn) {
     if (logLevels.has(level)) {
-        console[m[level]](logFn());
+        const method = m[level];
+        console[method](logFn());
     }
 }
 function logTrace() {

package/core/privacy.d.ts

@@ -86,18 +86,14 @@ export declare class AllowIfEntIsNotVisibleRule<TEnt extends Ent<TViewer>, TView
 export declare class AllowIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
+    rules: PrivacyPolicyRule[];
     constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
-    rules: {
-        apply(_v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
-    }[];
 }
 export declare class DenyIfEntIsVisiblePolicy<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicy<TEnt, TViewer> {
     private id;
     private options;
+    rules: PrivacyPolicyRule[];
     constructor(id: ID, options: LoadEntOptions<TEnt, TViewer>);
-    rules: {
-        apply(_v: Viewer, _ent?: Ent): Promise<PrivacyResult>;
-    }[];
 }
 export declare class DenyIfEntIsVisibleRule<TEnt extends Ent<TViewer>, TViewer extends Viewer> implements PrivacyPolicyRule<TEnt, TViewer> {
     private id;

package/core/privacy.js

@@ -225,7 +225,10 @@ class AllowIfEntIsVisiblePolicy {
     constructor(id, options) {
         this.id = id;
         this.options = options;
-        this.rules = [new AllowIfEntIsVisibleRule(this.id, this.options), exports.AlwaysDenyRule];
+        this.rules = [
+            new AllowIfEntIsVisibleRule(this.id, this.options),
+            exports.AlwaysDenyRule,
+        ];
     }
 }
 exports.AllowIfEntIsVisiblePolicy = AllowIfEntIsVisiblePolicy;
@@ -233,7 +236,10 @@ class DenyIfEntIsVisiblePolicy {
     constructor(id, options) {
         this.id = id;
         this.options = options;
-        this.rules = [new DenyIfEntIsVisibleRule(this.id, this.options), exports.AlwaysAllowRule];
+        this.rules = [
+            new DenyIfEntIsVisibleRule(this.id, this.options),
+            exports.AlwaysAllowRule,
+        ];
     }
 }
 exports.DenyIfEntIsVisiblePolicy = DenyIfEntIsVisiblePolicy;

package/core/query/index.d.ts

@@ -1,4 +1,6 @@
-export { EdgeQuery, BaseEdgeQuery, EdgeQueryFilter, PaginationInfo, } from "./query";
-export { AssocEdgeQueryBase, EdgeQuerySource } from "./assoc_query";
+export { BaseEdgeQuery, } from "./query";
+export type { EdgeQuery, EdgeQueryFilter, PaginationInfo } from "./query";
+export { AssocEdgeQueryBase } from "./assoc_query";
+export type { EdgeQuerySource } from "./assoc_query";
 export { CustomEdgeQueryBase } from "./custom_query";
 export { CustomClauseQuery } from "./custom_clause_query";

package/graphql/graphql.d.ts

@@ -192,6 +192,8 @@ export declare class GQLCapture {
     static getCustomInterfaces(): Map<string, CustomObject>;
     static getCustomUnions(): Map<string, CustomObject>;
     static getCustomTypes(): Map<string, CustomType>;
+    private static normalizeClassDecoratorContext;
+    private static normalizeMemberDecoratorContext;
     private static getNullableArg;
     static getProcessedCustomFields(): ProcessCustomFieldMap;
     static getProcessedCustomMutations(): ProcessedCustomField[];

package/graphql/graphql.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gqlFileUpload = exports.gqlConnection = exports.gqlContextType = exports.gqlMutation = exports.gqlQuery = exports.gqlUnionType = exports.gqlInterfaceType = exports.gqlObjectType = exports.gqlInputObjectType = exports.gqlArgType = exports.gqlField = exports.GQLCapture = exports.addCustomType = exports.isCustomType = exports.knownInterfaces = exports.knownDisAllowedNames = exports.knownAllowedNames = exports.CustomFieldType = void 0;
-const graphql_1 = require("graphql");
 const parse_1 = require("../parse_schema/parse");
 var CustomFieldType;
 (function (CustomFieldType) {
@@ -62,10 +61,17 @@ const isCustomType = (type) => {
 };
 exports.isCustomType = isCustomType;
 const isGraphQLScalarType = (type) => {
-    return (0, graphql_1.isScalarType)(type);
+    return !!type &&
+        typeof type === "object" &&
+        typeof type.serialize === "function" &&
+        typeof type.parseValue === "function" &&
+        typeof type.parseLiteral === "function";
 };
 const isGraphQLEnumType = (type) => {
-    return (0, graphql_1.isEnumType)(type);
+    return (!!type &&
+        typeof type === "object" &&
+        typeof type.getValues === "function" &&
+        typeof type.toConfig === "function");
 };
 const addCustomType = async (type, gqlCapture) => {
     // TODO these should return ReadOnly objects...
@@ -102,12 +108,21 @@ const addCustomType = async (type, gqlCapture) => {
         }
         catch (e) {
             if (type.secondaryImportPath) {
-                await (0, exports.addCustomType)({
-                    ...type,
-                    importPath: type.secondaryImportPath,
-                }, gqlCapture);
+                try {
+                    const r = require(type.secondaryImportPath);
+                    const ct = r[type.type];
+                    if (ct && isGraphQLScalarType(ct)) {
+                        type.scalarInfo = {
+                            description: ct.description,
+                            name: ct.name,
+                        };
+                        if (ct.specifiedByURL) {
+                            type.scalarInfo.specifiedByUrl = ct.specifiedByURL;
+                        }
+                    }
+                }
+                catch { }
             }
-            return;
         }
     }
     if (customType) {
@@ -145,8 +160,8 @@ const getType = (typ, result) => {
         return;
     }
     // GraphQLScalarType or GraphQLEnumType or ClassType
-    result.scalarType = isGraphQLScalarType(typ);
     result.enumType = isGraphQLEnumType(typ);
+    result.scalarType = !result.enumType && isGraphQLScalarType(typ);
     result.type = typ.name;
     return;
 };
@@ -195,6 +210,55 @@ class GQLCapture {
     static getCustomTypes() {
         return this.customTypes;
     }
+    static normalizeClassDecoratorContext(target, ctx) {
+        if (ctx && typeof ctx === "object" && ctx.kind === "class" && ctx.name) {
+            return {
+                kind: "class",
+                name: ctx.name,
+            };
+        }
+        if (typeof target === "function" && target.name) {
+            return {
+                kind: "class",
+                name: target.name,
+            };
+        }
+        return null;
+    }
+    static normalizeMemberDecoratorContext(target, ctxOrProperty, descriptor) {
+        if (ctxOrProperty &&
+            typeof ctxOrProperty === "object" &&
+            "kind" in ctxOrProperty &&
+            (ctxOrProperty.kind === "method" ||
+                ctxOrProperty.kind === "field" ||
+                ctxOrProperty.kind === "getter")) {
+            return {
+                kind: ctxOrProperty.kind,
+                name: ctxOrProperty.name,
+                static: ctxOrProperty.static,
+                private: ctxOrProperty.private,
+            };
+        }
+        if (typeof ctxOrProperty !== "string" &&
+            typeof ctxOrProperty !== "symbol") {
+            return null;
+        }
+        let kind = "field";
+        if (descriptor) {
+            if (typeof descriptor.value === "function") {
+                kind = "method";
+            }
+            else if (typeof descriptor.get === "function") {
+                kind = "getter";
+            }
+        }
+        return {
+            kind,
+            name: ctxOrProperty,
+            static: typeof target === "function",
+            private: false,
+        };
+    }
     static getNullableArg(fd) {
         let res = fd;
         if (fd.nullable === undefined) {
@@ -286,8 +350,10 @@ class GQLCapture {
         return result;
     }
     static gqlField(options) {
-        return function (_target, ctx) {
+        return function (target, ctxOrProperty, descriptor) {
+            const ctx = GQLCapture.normalizeMemberDecoratorContext(target, ctxOrProperty, descriptor);
             if (!GQLCapture.isEnabled() ||
+                !ctx ||
                 (ctx.kind !== "method" &&
                     ctx.kind !== "field" &&
                     ctx.kind !== "getter") ||
@@ -375,34 +441,35 @@ class GQLCapture {
     }
     static gqlArgType(options) {
         return function (target, ctx) {
-            return GQLCapture.customGQLObject(ctx, GQLCapture.customArgs, options);
+            return GQLCapture.customGQLObject(target, ctx, GQLCapture.customArgs, options);
         };
     }
     static gqlInputObjectType(options) {
         return function (target, ctx) {
-            return GQLCapture.customGQLObject(ctx, GQLCapture.customInputObjects, options);
+            return GQLCapture.customGQLObject(target, ctx, GQLCapture.customInputObjects, options);
         };
     }
     static gqlObjectType(options) {
         return function (target, ctx) {
-            return GQLCapture.customGQLObject(ctx, GQLCapture.customObjects, options);
+            return GQLCapture.customGQLObject(target, ctx, GQLCapture.customObjects, options);
         };
     }
     static gqlUnionType(options) {
         return function (target, ctx) {
-            return GQLCapture.customGQLObject(ctx, GQLCapture.customUnions, options);
+            return GQLCapture.customGQLObject(target, ctx, GQLCapture.customUnions, options);
         };
     }
     static gqlInterfaceType(options) {
         return function (target, ctx) {
-            return GQLCapture.customGQLObject(ctx, GQLCapture.customInterfaces, options);
+            return GQLCapture.customGQLObject(target, ctx, GQLCapture.customInterfaces, options);
         };
     }
-    static customGQLObject(ctx, map, options) {
-        if (!GQLCapture.isEnabled() || ctx.kind !== "class" || !ctx.name) {
+    static customGQLObject(target, ctx, map, options) {
+        const normalized = GQLCapture.normalizeClassDecoratorContext(target, ctx);
+        if (!GQLCapture.isEnabled() || !normalized) {
             return;
         }
-        let className = ctx.name.toString();
+        let className = normalized.name.toString();
         let nodeName = options?.name || className;
         map.set(className, {
             className,
@@ -416,16 +483,18 @@ class GQLCapture {
     }
     // we want to specify args if any, name, response if any
     static gqlQuery(options) {
-        return function (target, ctx) {
-            if (!GQLCapture.isEnabled()) {
+        return function (target, ctxOrProperty, descriptor) {
+            const ctx = GQLCapture.normalizeMemberDecoratorContext(target, ctxOrProperty, descriptor);
+            if (!GQLCapture.isEnabled() || !ctx || ctx.kind !== "method") {
                 return;
             }
             GQLCapture.customQueries.push(GQLCapture.getCustomField(ctx, options));
         };
     }
     static gqlMutation(options) {
-        return function (target, ctx) {
-            if (!GQLCapture.isEnabled()) {
+        return function (target, ctxOrProperty, descriptor) {
+            const ctx = GQLCapture.normalizeMemberDecoratorContext(target, ctxOrProperty, descriptor);
+            if (!GQLCapture.isEnabled() || !ctx || ctx.kind !== "method") {
                 return;
             }
             GQLCapture.customMutations.push(GQLCapture.getCustomField(ctx, options, true));

package/graphql/index.d.ts

@@ -1,12 +1,15 @@
-export { gqlFieldOptions, gqlObjectOptions, gqlField, gqlArgType, gqlInputObjectType, gqlObjectType, gqlQuery, gqlMutation, gqlContextType, gqlConnection, GraphQLConnection, GQLCapture, gqlFileUpload, CustomType, gqlInterfaceType, gqlUnionType, } from "./graphql";
+export { gqlField, gqlArgType, gqlInputObjectType, gqlObjectType, gqlQuery, gqlMutation, gqlContextType, gqlConnection, GQLCapture, gqlFileUpload, gqlInterfaceType, gqlUnionType, } from "./graphql";
+export type { CustomType, GraphQLConnection, gqlFieldOptions, gqlObjectOptions, } from "./graphql";
 export { GraphQLTime } from "./scalars/time";
 export { GraphQLDate } from "./scalars/date";
 export { GraphQLOrderByDirection } from "./scalars/orderby_direction";
 export { GraphQLPageInfo } from "./query/page_info";
-export { GraphQLEdge, GraphQLEdgeConnection } from "./query/edge_connection";
+export { GraphQLEdgeConnection } from "./query/edge_connection";
+export type { GraphQLEdge } from "./query/edge_connection";
 export { GraphQLEdgeType, GraphQLConnectionType, } from "./query/connection_type";
 export { GraphQLNodeInterface } from "./builtins/node";
 export { GraphQLConnectionInterface } from "./builtins/connection";
 export { GraphQLEdgeInterface } from "./builtins/edge";
-export { NodeResolver, EntNodeResolver, registerResolver, clearResolvers, resolveID, nodeIDEncoder, mustDecodeIDFromGQLID, mustDecodeNullableIDFromGQLID, encodeGQLID, } from "./node_resolver";
+export { EntNodeResolver, registerResolver, clearResolvers, resolveID, nodeIDEncoder, mustDecodeIDFromGQLID, mustDecodeNullableIDFromGQLID, encodeGQLID, } from "./node_resolver";
+export type { NodeResolver } from "./node_resolver";
 export { transformUnionTypes } from "./mutations/union";

package/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./core/base";
-export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, AssocEdge, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, setEntLoaderPrivacyConcurrencyLimit, getEntLoaderPrivacyConcurrencyLimit, } from "./core/ent";
-export { DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdgeInputOptions, AssocEdgeInput, } from "./action/operations";
+export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, AssocEdge, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, setEntLoaderPrivacyConcurrencyLimit, getEntLoaderPrivacyConcurrencyLimit, } from "./core/ent";
+export type { CustomQuery } from "./core/ent";
+export { EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, } from "./action/operations";
+export type { AssocEdgeInput, AssocEdgeInputOptions, DataOperation, EditNodeOptions, } from "./action/operations";
 export { setGlobalSchema } from "./core/global_schema";
 export { registerExtensionRuntime } from "./core/extensions";
 import DB from "./core/db";
@@ -12,7 +14,8 @@ export * from "./core/query_impl";
 export type { QueryExpression } from "./core/query_expression";
 export * from "./schema/";
 import * as q from "./core/clause";
-export { Clause, Expression, ParameterizedExpression } from "./core/clause";
+export { Expression, ParameterizedExpression } from "./core/clause";
+export type { Clause } from "./core/clause";
 declare const query: {
     Eq: typeof q.Eq;
     NotEq: typeof q.NotEq;
@@ -56,8 +59,10 @@ declare const query: {
     ParameterizedExpression: typeof q.ParameterizedExpression;
 };
 export { query };
-export { RequestContext, ContextCache } from "./core/context";
-export { IDViewer, LoggedOutViewer, IDViewerOptions } from "./core/viewer";
+export { ContextCache } from "./core/context";
+export type { RequestContext } from "./core/context";
+export { IDViewer, LoggedOutViewer } from "./core/viewer";
+export type { IDViewerOptions } from "./core/viewer";
 export { loadConfig } from "./core/config";
 export { setLogLevels } from "./core/logger";
 export * from "./core/metrics";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/schema/base_schema.d.ts

@@ -1,5 +1,5 @@
 import { FieldMap, Pattern, FieldOverrideMap } from "./schema";
-import { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from ".";
+import type { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from "./schema";
 import { PrivacyPolicy } from "../core/base";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;

package/schema/index.d.ts

@@ -1,7 +1,8 @@
-import Schema from "./schema";
-export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getFieldsWithEditPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, EdgeIndex, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, EdgeUpdateOperation, TransformedEdgeUpdateOperation, getTransformedReadClause, getObjectLoaderProperties, GlobalSchema, DBExtension, ActionField, } from "./schema";
-export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, SchemaConfig, } from "./base_schema";
+export type { Schema } from "./schema";
+export { DBType, getFields, getFieldsWithPrivacy, getFieldsWithEditPrivacy, getStorageKey, ActionOperation, NoFields, ConstraintType, requiredField, optionalField, SQLStatementOperation, getTransformedReadClause, getObjectLoaderProperties, } from "./schema";
+export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, } from "./base_schema";
+export type { Action, ActionField, AssocEdge, AssocEdgeGroup, Constraint, DBExtension, Edge, EdgeAction, EdgeIndex, EdgeUpdateOperation, Field, FieldMap, FieldOptions, ForeignKeyInfo, GlobalSchema, Index, InverseAssocEdge, Pattern, SchemaConstructor, SchemaInputType, TransformedEdgeUpdateOperation, TransformedUpdateOperation, Type, UpdateOperation, } from "./schema";
+export type { SchemaConfig } from "./base_schema";
 export * from "./field";
 export * from "./json_field";
 export * from "./struct_field";

package/schema/schema.d.ts

@@ -35,7 +35,7 @@ type FieldOverride = Pick<FieldOptions, "nullable" | "storageKey" | "serverDefau
 export type FieldOverrideMap = {
     [key: string]: FieldOverride;
 };
-export default interface Schema {
+export interface Schema {
     fields: FieldMap;
     fieldOverrides?: FieldOverrideMap;
     tableName?: string;
@@ -70,6 +70,7 @@ export interface AssocEdge {
 export interface EdgeAction {
     operation: ActionOperation;
     actionName?: string;
+    inputName?: string;
     hideFromGraphQL?: boolean;
     graphQLName?: string;
     actionOnlyFields?: ActionField[];
@@ -84,6 +85,7 @@ export interface InverseAssocEdge {
 export interface EdgeGroupAction {
     operation: ActionOperation.EdgeGroup;
     actionName?: string;
+    inputName?: string;
     hideFromGraphQL?: boolean;
     graphQLName?: string;
     actionOnlyFields?: ActionField[];