create-windy 0.1.0

package/template/apps/server/src/system/drizzle-scoped-repository.ts

@@ -0,0 +1,235 @@
+import { and, eq, inArray, isNull, sql, type SQL } from "drizzle-orm";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import type { PageResult } from "@windy/shared";
+import {
+  compileDrizzleDataScopePredicate,
+  type DrizzleDataScopeBinding,
+} from "../data-access/drizzle-predicate.js";
+import { DataAccessDeniedError } from "../data-access/errors.js";
+import {
+  assertEntityInDataScope,
+  type EntityDataScopeBinding,
+  type ScopedEntityRepository,
+} from "../data-access/scoped-repository.js";
+import type { DataScopeQuerySpecification } from "../data-access/query-specification.js";
+import type { RequestActor } from "../guards.js";
+import type { ManagedEntity } from "./entities.js";
+import {
+  DrizzleEntityRepository,
+  type DrizzleEntityRepositoryConfig,
+} from "./drizzle-repository.js";
+import type { EntityImportResult, EntityListQuery } from "./repository.js";
+
+export interface DrizzleScopedEntityRepositoryConfig<
+  T extends ManagedEntity,
+> extends DrizzleEntityRepositoryConfig<T> {
+  readonly dataScope: {
+    readonly drizzle: DrizzleDataScopeBinding;
+    readonly entity: EntityDataScopeBinding<T>;
+  };
+}
+
+export class DrizzleScopedEntityRepository<T extends ManagedEntity>
+  extends DrizzleEntityRepository<T>
+  implements ScopedEntityRepository<T>
+{
+  declare protected readonly config: DrizzleScopedEntityRepositoryConfig<T>;
+
+  constructor(
+    db: NodePgDatabase,
+    config: DrizzleScopedEntityRepositoryConfig<T>,
+  ) {
+    super(db, config);
+  }
+
+  async listScoped(
+    query: EntityListQuery,
+    searchFields: Array<keyof T>,
+    scope: DataScopeQuerySpecification,
+  ): Promise<PageResult<T>> {
+    await this.ensureSeeded();
+    const page = Math.max(1, query.page || 1);
+    const pageSize = Math.min(100, Math.max(1, query.pageSize || 20));
+    const where = this.scopedWhere(query, searchFields, scope);
+    const rows = await this.selectRows(
+      where,
+      query.sort,
+      pageSize,
+      (page - 1) * pageSize,
+    );
+    const [{ count = 0 } = { count: 0 }] = await this.countRows(where);
+    return {
+      items: rows.map(this.config.toEntity),
+      total: count,
+      page,
+      pageSize,
+    };
+  }
+
+  async allScoped(
+    query: EntityListQuery,
+    searchFields: Array<keyof T>,
+    scope: DataScopeQuerySpecification,
+  ): Promise<T[]> {
+    await this.ensureSeeded();
+    const rows = await this.selectRows(
+      this.scopedWhere(query, searchFields, scope),
+      query.sort,
+    );
+    return rows.map(this.config.toEntity);
+  }
+
+  async getScoped(
+    id: string,
+    scope: DataScopeQuerySpecification,
+  ): Promise<T | undefined> {
+    await this.ensureSeeded();
+    const [row] = await this.selectRows(this.idWhere(id, scope), undefined, 1);
+    if (row) return this.config.toEntity(row);
+    if (await super.get(id)) {
+      throw new DataAccessDeniedError();
+    }
+    return undefined;
+  }
+
+  async getManyScopedSnapshot(
+    ids: readonly string[],
+    scope: DataScopeQuerySpecification,
+  ): Promise<T[] | undefined> {
+    if (ids.length === 0) return [];
+    await this.ensureSeeded();
+    return this.db.transaction(
+      async (transaction) => {
+        await transaction.execute(sql`select 1`);
+        await this.afterBatchSnapshotEstablished();
+        const deletedAt = this.column("deletedAt");
+        const rows = (await transaction
+          .select()
+          .from(this.table())
+          .where(
+            and(
+              inArray(this.idColumn(), [...ids]),
+              deletedAt ? isNull(deletedAt) : undefined,
+              compileDrizzleDataScopePredicate(
+                scope,
+                this.config.dataScope.drizzle,
+              ),
+            ),
+          )) as Array<Record<string, unknown>>;
+        if (rows.length !== ids.length) return undefined;
+        const entities = new Map(
+          rows.map((row) => {
+            const entity = this.config.toEntity(row);
+            return [entity.id, entity];
+          }),
+        );
+        const ordered = ids.map((id) => entities.get(id));
+        return ordered.some((item) => !item) ? undefined : (ordered as T[]);
+      },
+      { isolationLevel: "repeatable read", accessMode: "read only" },
+    );
+  }
+
+  protected afterBatchSnapshotEstablished(): Promise<void> | void {}
+
+  async createScoped(
+    input: Partial<T>,
+    actor: RequestActor,
+    scope: DataScopeQuerySpecification,
+  ): Promise<T> {
+    assertEntityInDataScope(input, scope, this.config.dataScope.entity);
+    return super.create(input, actor);
+  }
+
+  async updateScoped(
+    id: string,
+    input: Partial<T>,
+    actor: RequestActor,
+    scope: DataScopeQuerySpecification,
+  ): Promise<T | undefined> {
+    const current = await this.getScoped(id, scope);
+    if (!current) return undefined;
+    const entity = {
+      ...current,
+      ...input,
+      id,
+      updatedAt: new Date().toISOString(),
+      updatedBy: actor.id,
+    } as T;
+    assertEntityInDataScope(entity, scope, this.config.dataScope.entity);
+    const rows = (await this.db
+      .update(this.table())
+      .set(this.config.toRow(entity))
+      .where(this.idWhere(id, scope))
+      .returning()) as Array<Record<string, unknown>>;
+    return rows[0] ? this.config.toEntity(rows[0]) : undefined;
+  }
+
+  softDeleteScoped(
+    id: string,
+    actor: RequestActor,
+    scope: DataScopeQuerySpecification,
+  ): Promise<T | undefined> {
+    return this.updateScoped(
+      id,
+      {
+        status: "archived",
+        deletedAt: new Date().toISOString(),
+        deletedBy: actor.id,
+      } as Partial<T>,
+      actor,
+      scope,
+    );
+  }
+
+  async importManyScoped(
+    inputs: Array<Partial<T>>,
+    actor: RequestActor,
+    scope: DataScopeQuerySpecification,
+    mode: "create" | "upsert" = "create",
+  ): Promise<EntityImportResult<T>> {
+    const result: EntityImportResult<T> = {
+      created: 0,
+      updated: 0,
+      skipped: 0,
+      items: [],
+    };
+    for (const input of inputs) {
+      const current = input.id
+        ? await this.getScoped(input.id, scope)
+        : undefined;
+      if (current && mode !== "upsert") {
+        result.skipped += 1;
+        continue;
+      }
+      const item = current
+        ? await this.updateScoped(current.id, input, actor, scope)
+        : await this.createScoped(input, actor, scope);
+      if (!item) continue;
+      if (current) result.updated += 1;
+      else result.created += 1;
+      result.items.push(item);
+    }
+    return result;
+  }
+
+  private scopedWhere(
+    query: EntityListQuery,
+    searchFields: Array<keyof T>,
+    scope: DataScopeQuerySpecification,
+  ): SQL | undefined {
+    return and(
+      this.buildWhere(query, searchFields),
+      compileDrizzleDataScopePredicate(scope, this.config.dataScope.drizzle),
+    );
+  }
+
+  private idWhere(id: string, scope: DataScopeQuerySpecification): SQL {
+    const deletedAt = this.column("deletedAt");
+    return and(
+      eq(this.idColumn(), id),
+      deletedAt ? isNull(deletedAt) : undefined,
+      compileDrizzleDataScopePredicate(scope, this.config.dataScope.drizzle),
+    ) as SQL;
+  }
+}

package/template/apps/server/src/system/drizzle-system.ts

@@ -0,0 +1,361 @@
+import {
+  departments,
+  dictionaries,
+  featureFlags,
+  // @windy-module system.license begin
+  legacyLicenses,
+  // @windy-module system.license end
+  menus,
+  roles,
+  users,
+} from "@windy/database";
+import type { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { ManifestFeatureRepository } from "../feature/manifest-feature-repository.js";
+import type {
+  ManagedDepartment,
+  ManagedDictionary,
+  ManagedFeature,
+  // @windy-module system.license begin
+  ManagedLicense,
+  // @windy-module system.license end
+  ManagedMenu,
+  ManagedRole,
+  ManagedUser,
+} from "./entities.js";
+import {
+  array,
+  auditEntity,
+  auditRow,
+  date,
+  iso,
+  optionalIso,
+  pick,
+} from "./drizzle-mapping.js";
+import {
+  DrizzleEntityRepository,
+  type DrizzleEntityRepositoryConfig,
+} from "./drizzle-repository.js";
+import {
+  DrizzleScopedEntityRepository,
+  type DrizzleScopedEntityRepositoryConfig,
+} from "./drizzle-scoped-repository.js";
+import type { EntityRepository } from "./repository.js";
+import type { ScopedEntityRepository } from "../data-access/scoped-repository.js";
+import { userDataScopeBinding } from "./user-data-scope.js";
+
+export interface DrizzleSystemRepositorySeeds {
+  users: ManagedUser[];
+  roles: ManagedRole[];
+  departments: ManagedDepartment[];
+  menus: ManagedMenu[];
+  dictionaries: ManagedDictionary[];
+  features: ManagedFeature[];
+  // @windy-module system.license begin
+  licenses: ManagedLicense[];
+  // @windy-module system.license end
+}
+
+export interface DrizzleSystemRepositories {
+  users: ScopedEntityRepository<ManagedUser>;
+  roles: EntityRepository<ManagedRole>;
+  departments: EntityRepository<ManagedDepartment>;
+  menus: EntityRepository<ManagedMenu>;
+  dictionaries: EntityRepository<ManagedDictionary>;
+  features: ManifestFeatureRepository;
+  // @windy-module system.license begin
+  licenses: EntityRepository<ManagedLicense>;
+  // @windy-module system.license end
+}
+
+export function createDrizzleSystemRepositories(
+  db: NodePgDatabase,
+  seeds: DrizzleSystemRepositorySeeds,
+): DrizzleSystemRepositories {
+  return {
+    users: new DrizzleScopedEntityRepository(db, userConfig(seeds.users)),
+    roles: repo(db, roleConfig(seeds.roles)),
+    departments: repo(db, departmentConfig(seeds.departments)),
+    menus: repo(db, menuConfig(seeds.menus)),
+    dictionaries: repo(db, dictionaryConfig(seeds.dictionaries)),
+    features: new ManifestFeatureRepository(
+      repo(db, featureConfig(seeds.features)),
+    ),
+    // @windy-module system.license begin
+    licenses: repo(db, licenseConfig(seeds.licenses)),
+    // @windy-module system.license end
+  };
+}
+
+function repo<
+  T extends
+    | ManagedUser
+    | ManagedRole
+    | ManagedDepartment
+    | ManagedMenu
+    | ManagedDictionary
+    | ManagedFeature
+    // @windy-module system.license begin
+    | ManagedLicense,
+  // @windy-module system.license end
+>(db: NodePgDatabase, config: DrizzleEntityRepositoryConfig<T>) {
+  return new DrizzleEntityRepository<T>(db, config);
+}
+
+function userConfig(
+  seedItems: ManagedUser[],
+): DrizzleScopedEntityRepositoryConfig<ManagedUser> {
+  return {
+    table: users,
+    idColumn: "id",
+    seedItems,
+    dataScope: {
+      drizzle: {
+        ownerId: users.id,
+        tenant: { mode: "fixed", tenantId: "single-tenant" },
+        dimensions: { departmentId: users.departmentId },
+      },
+      entity: userDataScopeBinding,
+    },
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "username",
+        "displayName",
+        "email",
+        "phone",
+        "departmentId",
+        "roleIds",
+        "postIds",
+        "status",
+      ]),
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, [
+          "id",
+          "username",
+          "displayName",
+          "email",
+          "phone",
+          "departmentId",
+          "postIds",
+          "status",
+        ]),
+        roleIds: array(row.roleIds),
+      }) as ManagedUser,
+  };
+}
+
+function roleConfig(
+  seedItems: ManagedRole[],
+): DrizzleEntityRepositoryConfig<ManagedRole> {
+  return {
+    table: roles,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "code",
+        "name",
+        "dataScope",
+        "permissionKeys",
+        "menuKeys",
+        "departmentIds",
+        "status",
+      ]),
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, ["id", "code", "name", "dataScope", "status"]),
+        permissionKeys: array(row.permissionKeys),
+        menuKeys: array(row.menuKeys),
+        departmentIds: array(row.departmentIds),
+      }) as ManagedRole,
+  };
+}
+
+function departmentConfig(
+  seedItems: ManagedDepartment[],
+): DrizzleEntityRepositoryConfig<ManagedDepartment> {
+  return {
+    table: departments,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, ["id", "parentId", "name", "code", "order", "status"]),
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, ["id", "parentId", "name", "code", "order", "status"]),
+      }) as ManagedDepartment,
+  };
+}
+
+function menuConfig(
+  seedItems: ManagedMenu[],
+): DrizzleEntityRepositoryConfig<ManagedMenu> {
+  return {
+    table: menus,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "key",
+        "title",
+        "type",
+        "order",
+        "path",
+        "component",
+        "icon",
+        "permissionKey",
+        "featureKey",
+        "parentKey",
+        "status",
+      ]),
+      visible: item.visible ? "visible" : "hidden",
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, [
+          "id",
+          "key",
+          "title",
+          "type",
+          "order",
+          "path",
+          "component",
+          "icon",
+          "permissionKey",
+          "featureKey",
+          "parentKey",
+          "status",
+        ]),
+        visible: row.visible !== "hidden",
+      }) as ManagedMenu,
+  };
+}
+
+function dictionaryConfig(
+  seedItems: ManagedDictionary[],
+): DrizzleEntityRepositoryConfig<ManagedDictionary> {
+  return {
+    table: dictionaries,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, ["id", "code", "name", "description", "status"]),
+      items: item.items || [],
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, ["id", "code", "name", "description", "status"]),
+        items: array(row.items),
+      }) as ManagedDictionary,
+  };
+}
+
+function featureConfig(
+  seedItems: ManagedFeature[],
+): DrizzleEntityRepositoryConfig<ManagedFeature> {
+  return {
+    table: featureFlags,
+    idColumn: "key",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      key: item.key || item.id,
+      module: item.module,
+      label: item.label,
+      description: item.description,
+      enabled: item.enabled,
+      visible: item.visible,
+      stage: item.stage,
+      licenseRequired: false,
+      licenseKey: item.requiredEntitlement,
+      allowedLicenseVersions: item.licenseVersionOverride,
+      dependencies: item.dependencies || [],
+      status: item.status,
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        id: String(row.key),
+        key: String(row.key),
+        module: String(row.module),
+        label: String(row.label),
+        description: row.description as string | undefined,
+        enabled: Boolean(row.enabled),
+        visible: row.visible === "hidden" ? "hidden" : "visible",
+        stage: String(row.stage || "stable") as ManagedFeature["stage"],
+        requiredEntitlement: row.licenseKey
+          ? (row.licenseKey as NonNullable<
+              ManagedFeature["requiredEntitlement"]
+            >)
+          : undefined,
+        licenseVersionOverride: Array.isArray(row.allowedLicenseVersions)
+          ? (row.allowedLicenseVersions as NonNullable<
+              ManagedFeature["licenseVersionOverride"]
+            >)
+          : undefined,
+        dependencies: array(row.dependencies),
+        status: String(row.status || "active") as ManagedFeature["status"],
+      }) as ManagedFeature,
+  };
+}
+
+// @windy-module system.license begin
+function licenseConfig(
+  seedItems: ManagedLicense[],
+): DrizzleEntityRepositoryConfig<ManagedLicense> {
+  return {
+    table: legacyLicenses,
+    idColumn: "id",
+    seedItems,
+    toRow: (item) => ({
+      ...auditRow(item),
+      ...pick(item, [
+        "id",
+        "licenseKey",
+        "subject",
+        "machineCode",
+        "publicKeyId",
+        "edition",
+        "modules",
+        "status",
+      ]),
+      issuedAt: date(item.issuedAt),
+      expiresAt: item.expiresAt ? date(item.expiresAt) : undefined,
+      payload: { modules: item.modules },
+      signature: "",
+    }),
+    toEntity: (row) =>
+      ({
+        ...auditEntity(row),
+        ...pick(row, [
+          "id",
+          "licenseKey",
+          "subject",
+          "machineCode",
+          "publicKeyId",
+          "edition",
+          "status",
+        ]),
+        modules: array(row.modules),
+        issuedAt: iso(row.issuedAt),
+        expiresAt: optionalIso(row.expiresAt),
+      }) as ManagedLicense,
+  };
+}
+// @windy-module system.license end

package/template/apps/server/src/system/entities.ts

@@ -0,0 +1,78 @@
+import type {
+  DepartmentNode,
+  EntitlementKey,
+  EntityAuditFields,
+  FeatureFlagDefinition,
+  LifecycleStatus,
+  MenuNode,
+  RoleDefinition,
+  UserAccount,
+} from "@windy/shared";
+
+export interface ManagedEntity extends EntityAuditFields {
+  id: string;
+  status: LifecycleStatus;
+}
+
+export type ManagedUser = UserAccount;
+
+export type ManagedRole = RoleDefinition;
+
+export type ManagedDepartment = DepartmentNode;
+
+export interface ManagedMenu extends ManagedEntity {
+  key: string;
+  title: string;
+  type: MenuNode["type"];
+  order: number;
+  visible: boolean;
+  path?: string;
+  component?: string;
+  icon?: string;
+  permissionKey?: string;
+  featureKey?: string;
+  parentKey?: string;
+}
+
+export interface DictionaryItem {
+  label: string;
+  value: string;
+  status: LifecycleStatus;
+  order: number;
+}
+
+export interface ManagedDictionary extends ManagedEntity {
+  code: string;
+  name: string;
+  description?: string;
+  items: DictionaryItem[];
+}
+
+export interface ManagedFeature extends ManagedEntity {
+  key: string;
+  label: string;
+  module: string;
+  description?: string;
+  visible: FeatureFlagDefinition["visible"];
+  enabled: boolean;
+  stage: FeatureFlagDefinition["stage"];
+  requiredEntitlement?: EntitlementKey;
+  allowedLicenseVersions?: FeatureFlagDefinition["allowedLicenseVersions"];
+  manifestAllowedLicenseVersions?: FeatureFlagDefinition["allowedLicenseVersions"];
+  licenseVersionOverride?:
+    | FeatureFlagDefinition["allowedLicenseVersions"]
+    | null;
+  licenseVersionSource?: "manifest" | "override";
+  dependencies?: string[];
+}
+
+export interface ManagedLicense extends ManagedEntity {
+  licenseKey: string;
+  subject: string;
+  machineCode: string;
+  publicKeyId: string;
+  edition: string;
+  modules: string[];
+  issuedAt: string;
+  expiresAt?: string;
+}