@microsoft/rayfin-connector-fabric-graphql 1.34.0-alpha.1221 → 1.34.0-alpha.1270

package/dist/types.d.ts

@@ -1,59 +1,92 @@
-import { METHODS_FOR_CRUD_OPERATION, type ConnectorMarker, type CrudOperation } from '@microsoft/rayfin-connectors';
-import type { EntitySchema, GraphQLEntityClient } from '@microsoft/rayfin-data';
-/**
- * Re-exported from `@microsoft/rayfin-connectors` so the runtime
- * allow-list (`ConnectorConfig.operations`), the CLI validators in
- * `@microsoft/rayfin-tools-common`, and this type marker all reference
- * the same union and cannot drift.
- */
+import { METHODS_FOR_CRUD_OPERATION, type ConnectorConfig, type ConnectorMarker, type ConnectorEntityClient, type ConnectorType, type CrudOperation, type WhereUniqueOf } from '@microsoft/rayfin-connectors';
+import type { EntitySchema } from '@microsoft/rayfin-data';
+/** Re-export of the shared CRUD-operation union from `@microsoft/rayfin-connectors`. */
 export type { CrudOperation };
 /**
- * The subset of `GraphQLEntityClient` method names associated with each
- * CRUD operation. Derived from the shared runtime constant
- * `METHODS_FOR_CRUD_OPERATION` in `@microsoft/rayfin-connectors`, so the
- * compile-time gate and runtime gate use the exact same mapping.
+ * The {@link ConnectorEntityClient} method names associated with a CRUD
+ * operation, read from the runtime constant `METHODS_FOR_CRUD_OPERATION`.
  */
 type MethodsFor<TOp extends CrudOperation> = (typeof METHODS_FOR_CRUD_OPERATION)[TOp][number];
+/** Entity-client method names that require a declared primary key. */
+type ByKeyMethod = 'findByKey' | 'update' | 'delete';
 /**
- * Narrows `GraphQLEntityClient<TSchema, TEntity>` to only the methods
- * permitted by `TOps`. Disallowed methods become inaccessible at
- * compile time — calling `connector.Entity.update(...)` on a `'read'`
- * connector is a `Property 'update' does not exist` error.
+ * `true` when entity `TEntity` in `TSchema` declares a usable primary key,
+ * `false` when {@link WhereUniqueOf} resolves to `never` (`primaryKey: []`,
+ * `primaryKey` omitted, or no `Source` phantom).
+ */
+type HasPrimaryKey<TSchema extends EntitySchema, TEntity extends keyof TSchema> = [WhereUniqueOf<TSchema[TEntity]>] extends [never] ? false : true;
+/**
+ * The entity client for one schema entry, restricted to the methods permitted
+ * by two gates:
+ * - **CRUD ops** (`TOps`) — keeps only the methods mapped to the connector's
+ *   declared operations via `METHODS_FOR_CRUD_OPERATION`.
+ * - **Primary key** — when the entry declares no key, {@link ByKeyMethod}
+ *   (`findByKey`/`update`/`delete`) is removed from the type; `create`
+ *   and the key-agnostic reads remain.
+ *
+ * `TDialect` is the connector's type literal; it flows into
+ * `ConnectorEntityClient` so the mutation methods return `DbOperationResult`
+ * for connectors without read-after-write (Fabric Warehouse) and the entity
+ * row otherwise.
  */
-export type RestrictedEntityClient<TSchema extends EntitySchema, TEntity extends keyof TSchema & string, TOps extends CrudOperation> = Pick<GraphQLEntityClient<TSchema, TEntity>, MethodsFor<TOps> & keyof GraphQLEntityClient<TSchema, TEntity>>;
+export type RestrictedEntityClient<TSchema extends EntitySchema, TEntity extends keyof TSchema & string, TOps extends CrudOperation, TDialect extends ConnectorType = ConnectorType> = Pick<ConnectorEntityClient<TSchema, TEntity, TDialect>, HasPrimaryKey<TSchema, TEntity> extends true ? MethodsFor<TOps> : Exclude<MethodsFor<TOps>, ByKeyMethod>>;
 /**
  * Type-level entity API for a Category A connector: one
- * `RestrictedEntityClient` per entity in the connector's schema, gated
- * by `TOps`. Mirrors the shape of `TypedDataClients<TSchema>` from
- * `@microsoft/rayfin-data` but with CRUD gating layered on.
+ * {@link RestrictedEntityClient} per entity in the schema, gated by `TOps`
+ * and typed for the connector's `TDialect`.
  */
-export type RestrictedDataApi<TSchema extends EntitySchema, TOps extends CrudOperation = CrudOperation> = {
-    [K in keyof TSchema & string]: RestrictedEntityClient<TSchema, K, TOps>;
+export type RestrictedDataApi<TSchema extends EntitySchema, TOps extends CrudOperation = CrudOperation, TDialect extends ConnectorType = ConnectorType> = {
+    [K in keyof TSchema & string]: RestrictedEntityClient<TSchema, K, TOps, TDialect>;
 };
 /**
- * Phantom marker for a Category A (GraphQL-backed) connector instance.
+ * The CRUD-operation union a connector permits, read from its
+ * {@link ConnectorConfig}. `operations` is a literal tuple (the CLI emits the
+ * config `as const satisfies ConnectorConfig`), so `[number]` recovers the
+ * exact verbs. `NonNullable` drops the `| undefined` the optional `operations?`
+ * adds, so a widened `ConnectorConfig` still yields the full {@link CrudOperation}
+ * union.
+ */
+type OpsOf<TConfig extends ConnectorConfig> = NonNullable<TConfig['operations']>[number];
+/**
+ * Phantom marker for a Category A (GraphQL-backed) connector instance. The CLI
+ * emits a per-connector `schema.ts` declaring e.g.
+ * `type SalesDbSchema = GraphQLBackedConnector<{ Product: typeof Product }, typeof connectorConfig>;`,
+ * and the `client.connectors.<name>` proxy resolves to a
+ * {@link RestrictedDataApi} exposing only the permitted CRUD methods.
  *
- * Builders never construct this directly. The CLI generates a
- * `schema.ts` per connector that declares e.g.
- * `type SalesDbSchema = GraphQLBackedConnector<{ Product: typeof Product }, 'read'>;`
- * and the typed `client.connectors.salesDb` proxy resolves to a
- * `RestrictedDataApi<...>` whose entity clients only expose the
- * permitted CRUD methods.
+ * The second parameter is the connector's own `connectorConfig` type (via
+ * `typeof connectorConfig`), so the permitted operations ({@link OpsOf}) and
+ * the dialect (`TConfig['connector']`) are both derived from one source. The
+ * dialect drives the mutation return type: `DbOperationResult` for connectors
+ * without read-after-write (Fabric Warehouse), the entity row otherwise. For
+ * the literals to survive, declare the config with an
+ * `as const satisfies ConnectorConfig` clause (a `: ConnectorConfig`
+ * annotation widens `connector` and `operations`).
  *
- * Both type parameters are phantom — the fields exist only at the
- * type level so the mapped type in `@microsoft/rayfin-connectors`
- * can infer them via `infer S`, `infer O`.
+ * Both parameters are phantom (type-level only) so the mapped type in
+ * `@microsoft/rayfin-connectors` can infer them.
+ *
+ * Key each entity name to its **constructor** (`typeof Product`), not its
+ * instance type. The constructor carries the `RayfinPrimaryKey` phantom from
+ * `Source({ primaryKey })` used to derive the composite/custom `where` shape;
+ * a bare instance entry has no phantom and is therefore treated as keyless
+ * (no by-key methods).
  *
  * @example
  * ```ts
- * type LakehouseSchema = GraphQLBackedConnector<{ Product: typeof Product }, 'read'>;
+ * const connectorConfig = {
+ *   connector: 'fabric-warehouse',
+ *   operations: ['read', 'create', 'update', 'delete'],
+ * } as const satisfies ConnectorConfig;
+ *
  * type SalesDbSchema = GraphQLBackedConnector<
- *   { Product: typeof Product; Customer: typeof Customer }
+ *   { Product: typeof Product; Customer: typeof Customer },
+ *   typeof connectorConfig
  * >;
  * ```
  */
-export interface GraphQLBackedConnector<TSchema extends EntitySchema = EntitySchema, TOps extends CrudOperation = CrudOperation> extends ConnectorMarker<RestrictedDataApi<TSchema, TOps>> {
+export interface GraphQLBackedConnector<TSchema extends EntitySchema = EntitySchema, TConfig extends ConnectorConfig = ConnectorConfig> extends ConnectorMarker<RestrictedDataApi<TSchema, OpsOf<TConfig>, TConfig['connector']>> {
     readonly __schema?: TSchema;
-    readonly __ops?: TOps;
+    readonly __config?: TConfig;
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/rayfin-connector-fabric-graphql",
-  "version": "1.34.0-alpha.1221",
+  "version": "1.34.0-alpha.1270",
   "description": "Experimental Cat A GraphQL-backed connector types for the Rayfin SDK. Provides the entity-oriented marker (GraphQLBackedConnector) and CRUD operation gating used by the typed client.connectors.<name>.<Entity>.select(...).execute() surface.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
     "rimraf": "~6.0.1"
   },
   "dependencies": {
-    "@microsoft/rayfin-data": "1.34.0-alpha.1221",
-    "@microsoft/rayfin-connectors": "1.34.0-alpha.1221"
+    "@microsoft/rayfin-connectors": "1.34.0-alpha.1270",
+    "@microsoft/rayfin-data": "1.34.0-alpha.1270"
   },
   "publishConfig": {
     "registry": "https://npm.pkg.github.com",