@prisma-next/target-postgres 0.14.0-dev.55 → 0.14.0-dev.56

package/dist/schema-node-kinds-ClScchhi.mjs

@@ -1,76 +0,0 @@
-import { relationalNodeEntityKind, relationalNodeGranularity } from "@prisma-next/sql-schema-ir/types";
-//#region src/core/schema-ir/schema-node-kinds.ts
-/**
-* The `nodeKind` discriminant for each Postgres schema-diff node. Each node
-* carries a unique value; the static `is`/`assert` guards compare against these
-* identifiers rather than spelling the string inline or using `instanceof`. The
-* field is an enumerable own property carried on every node instance.
-*/
-const PostgresSchemaNodeKind = {
-	database: "postgres-database",
-	namespace: "postgres-namespace",
-	table: "postgres-table",
-	policy: "postgres-policy",
-	role: "postgres-role"
-};
-/**
-* The one real map from a Postgres-specific `nodeKind` to the
-* framework-neutral {@link DiffSubjectGranularity} its diff issues carry —
-* resolution is by `nodeKind` equality against this map, never a
-* `nodeKind`-suffix string match and never anything stamped on the node.
-*/
-const POSTGRES_NODE_GRANULARITY = {
-	[PostgresSchemaNodeKind.database]: "structural",
-	[PostgresSchemaNodeKind.namespace]: "namespace",
-	[PostgresSchemaNodeKind.table]: "entity",
-	[PostgresSchemaNodeKind.policy]: "structural",
-	[PostgresSchemaNodeKind.role]: "structural"
-};
-function isPostgresSchemaNodeKind(nodeKind) {
-	return Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);
-}
-/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */
-function postgresNodeGranularity(nodeKind) {
-	return POSTGRES_NODE_GRANULARITY[nodeKind];
-}
-/**
-* The subject granularity for any node kind that appears in a Postgres diff
-* tree — the tree mixes Postgres-specific kinds (database/namespace/table/
-* policy/role) with the relational leaf kinds (columns, constraints, indexes,
-* …), so this dispatches to whichever family/target map owns the kind. Called
-* on demand by consumers (the family verdict, the framework aggregate's
-* unclaimed-elements sweep, via the {@link
-* import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
-* capability) — never stamped onto the issue or the node.
-*/
-function postgresDiffSubjectGranularity(nodeKind) {
-	return isPostgresSchemaNodeKind(nodeKind) ? postgresNodeGranularity(nodeKind) : relationalNodeGranularity(nodeKind);
-}
-/**
-* The one real map from a Postgres-specific `nodeKind` to its storage
-* `entityKind` — the same vocabulary the contract storage's `entries`
-* dictionary keys use. Only the whole-table kind has an entity of its own;
-* database/namespace/policy/role nodes map to nothing here (a namespace is
-* addressed by id, not by an `entries` kind; policies and roles are
-* structural, never a sibling space's unclaimed entity).
-*/
-const POSTGRES_NODE_ENTITY_KIND = { [PostgresSchemaNodeKind.table]: "table" };
-/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */
-function postgresNodeEntityKind(nodeKind) {
-	return POSTGRES_NODE_ENTITY_KIND[nodeKind];
-}
-/**
-* The storage `entityKind` for any node kind that appears in a Postgres diff
-* tree — sibling of {@link postgresDiffSubjectGranularity}, dispatching the
-* same way to whichever family/target map owns the kind. Called on demand by
-* the framework aggregate's unclaimed-elements sweep via the {@link
-* import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
-* capability — never stamped onto the issue or the node.
-*/
-function postgresDiffSubjectEntityKind(nodeKind) {
-	return isPostgresSchemaNodeKind(nodeKind) ? postgresNodeEntityKind(nodeKind) : relationalNodeEntityKind(nodeKind);
-}
-//#endregion
-export { postgresDiffSubjectEntityKind as n, postgresDiffSubjectGranularity as r, PostgresSchemaNodeKind as t };
-
-//# sourceMappingURL=schema-node-kinds-ClScchhi.mjs.map

package/dist/schema-node-kinds-ClScchhi.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-node-kinds-ClScchhi.mjs","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts"],"sourcesContent":["import type {\n  DiffableNode,\n  DiffSubjectGranularity,\n} from '@prisma-next/framework-components/control';\nimport {\n  relationalNodeEntityKind,\n  relationalNodeGranularity,\n  type SqlSchemaIRNode,\n} from '@prisma-next/sql-schema-ir/types';\n\n/**\n * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements\n * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`\n * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)\n * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node\n * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).\n */\nexport type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;\n\n/**\n * The `nodeKind` discriminant for each Postgres schema-diff node. Each node\n * carries a unique value; the static `is`/`assert` guards compare against these\n * identifiers rather than spelling the string inline or using `instanceof`. The\n * field is an enumerable own property carried on every node instance.\n */\nexport const PostgresSchemaNodeKind = {\n  database: 'postgres-database',\n  namespace: 'postgres-namespace',\n  table: 'postgres-table',\n  policy: 'postgres-policy',\n  role: 'postgres-role',\n} as const;\n\nexport type PostgresSchemaNodeKind =\n  (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];\n\n/**\n * The one real map from a Postgres-specific `nodeKind` to the\n * framework-neutral {@link DiffSubjectGranularity} its diff issues carry —\n * resolution is by `nodeKind` equality against this map, never a\n * `nodeKind`-suffix string match and never anything stamped on the node.\n */\nconst POSTGRES_NODE_GRANULARITY: Readonly<Record<PostgresSchemaNodeKind, DiffSubjectGranularity>> =\n  {\n    [PostgresSchemaNodeKind.database]: 'structural',\n    [PostgresSchemaNodeKind.namespace]: 'namespace',\n    [PostgresSchemaNodeKind.table]: 'entity',\n    [PostgresSchemaNodeKind.policy]: 'structural',\n    [PostgresSchemaNodeKind.role]: 'structural',\n  };\n\nfunction isPostgresSchemaNodeKind(nodeKind: string): nodeKind is PostgresSchemaNodeKind {\n  return Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);\n}\n\n/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */\nexport function postgresNodeGranularity(nodeKind: PostgresSchemaNodeKind): DiffSubjectGranularity {\n  return POSTGRES_NODE_GRANULARITY[nodeKind];\n}\n\n/**\n * The subject granularity for any node kind that appears in a Postgres diff\n * tree — the tree mixes Postgres-specific kinds (database/namespace/table/\n * policy/role) with the relational leaf kinds (columns, constraints, indexes,\n * …), so this dispatches to whichever family/target map owns the kind. Called\n * on demand by consumers (the family verdict, the framework aggregate's\n * unclaimed-elements sweep, via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability) — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectGranularity(nodeKind: string): DiffSubjectGranularity {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeGranularity(nodeKind)\n    : relationalNodeGranularity(nodeKind);\n}\n\n/**\n * The one real map from a Postgres-specific `nodeKind` to its storage\n * `entityKind` — the same vocabulary the contract storage's `entries`\n * dictionary keys use. Only the whole-table kind has an entity of its own;\n * database/namespace/policy/role nodes map to nothing here (a namespace is\n * addressed by id, not by an `entries` kind; policies and roles are\n * structural, never a sibling space's unclaimed entity).\n */\nconst POSTGRES_NODE_ENTITY_KIND: Partial<Readonly<Record<PostgresSchemaNodeKind, string>>> = {\n  [PostgresSchemaNodeKind.table]: 'table',\n};\n\n/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */\nexport function postgresNodeEntityKind(nodeKind: PostgresSchemaNodeKind): string | undefined {\n  return POSTGRES_NODE_ENTITY_KIND[nodeKind];\n}\n\n/**\n * The storage `entityKind` for any node kind that appears in a Postgres diff\n * tree — sibling of {@link postgresDiffSubjectGranularity}, dispatching the\n * same way to whichever family/target map owns the kind. Called on demand by\n * the framework aggregate's unclaimed-elements sweep via the {@link\n * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}\n * capability — never stamped onto the issue or the node.\n */\nexport function postgresDiffSubjectEntityKind(nodeKind: string): string | undefined {\n  return isPostgresSchemaNodeKind(nodeKind)\n    ? postgresNodeEntityKind(nodeKind)\n    : relationalNodeEntityKind(nodeKind);\n}\n"],"mappings":";;;;;;;;AAyBA,MAAa,yBAAyB;CACpC,UAAU;CACV,WAAW;CACX,OAAO;CACP,QAAQ;CACR,MAAM;AACR;;;;;;;AAWA,MAAM,4BACJ;EACG,uBAAuB,WAAW;EAClC,uBAAuB,YAAY;EACnC,uBAAuB,QAAQ;EAC/B,uBAAuB,SAAS;EAChC,uBAAuB,OAAO;AACjC;AAEF,SAAS,yBAAyB,UAAsD;CACtF,OAAO,OAAO,OAAO,2BAA2B,QAAQ;AAC1D;;AAGA,SAAgB,wBAAwB,UAA0D;CAChG,OAAO,0BAA0B;AACnC;;;;;;;;;;;AAYA,SAAgB,+BAA+B,UAA0C;CACvF,OAAO,yBAAyB,QAAQ,IACpC,wBAAwB,QAAQ,IAChC,0BAA0B,QAAQ;AACxC;;;;;;;;;AAUA,MAAM,4BAAuF,GAC1F,uBAAuB,QAAQ,QAClC;;AAGA,SAAgB,uBAAuB,UAAsD;CAC3F,OAAO,0BAA0B;AACnC;;;;;;;;;AAUA,SAAgB,8BAA8B,UAAsC;CAClF,OAAO,yBAAyB,QAAQ,IACpC,uBAAuB,QAAQ,IAC/B,yBAAyB,QAAQ;AACvC"}