sonamu 0.5.7 → 0.7.0

package/src/entity/entity-utils.ts

@@ -1,291 +0,0 @@
-import inflection from "inflection";
-import {
-  BelongsToOneRelationProp,
-  BigIntegerProp,
-  BooleanProp,
-  DateProp,
-  DateTimeProp,
-  DecimalProp,
-  DistributiveOmit,
-  DoubleProp,
-  EnumProp,
-  FloatProp,
-  HasManyRelationProp,
-  IntegerProp,
-  JsonProp,
-  ManyToManyRelationProp,
-  OneToOneRelationProp,
-  EntityIndex,
-  StringProp,
-  TextProp,
-  TimeProp,
-  TimestampProp,
-  UuidProp,
-  VirtualProp,
-} from "../types/types";
-import { asArray } from "../utils/model";
-
-export const p = {
-  integer,
-  bigInteger,
-  text,
-  string,
-  float,
-  double,
-  decimal,
-  boolean,
-  date,
-  dateTime,
-  time,
-  timestamp,
-  json,
-  uuid,
-  enums,
-  virtual,
-  relationOneToOne,
-  relationBelongsToOne,
-  relationHasMany,
-  relationManyToMany,
-};
-
-function integer(
-  name: string,
-  option?: Omit<IntegerProp, "name" | "type">
-): IntegerProp {
-  return {
-    name,
-    type: "integer",
-    ...option,
-  };
-}
-function bigInteger(
-  name: string,
-  option?: Omit<BigIntegerProp, "name" | "type">
-): BigIntegerProp {
-  return {
-    name,
-    type: "bigInteger",
-    ...option,
-  };
-}
-function text(name: string, option: Omit<TextProp, "name" | "type">): TextProp {
-  return {
-    name,
-    type: "text",
-    ...option,
-  };
-}
-function string(
-  name: string,
-  option: Omit<StringProp, "name" | "type">
-): StringProp {
-  return {
-    name,
-    type: "string",
-    ...option,
-  };
-}
-function float(
-  name: string,
-  option?: Omit<FloatProp, "name" | "type">
-): FloatProp {
-  return {
-    name,
-    type: "float",
-    precision: 8,
-    scale: 2,
-    ...option,
-  };
-}
-function double(
-  name: string,
-  option?: Omit<DoubleProp, "name" | "type">
-): DoubleProp {
-  return {
-    name,
-    type: "double",
-    precision: 8,
-    scale: 2,
-    ...option,
-  };
-}
-function decimal(
-  name: string,
-  option?: Omit<DecimalProp, "name" | "type">
-): DecimalProp {
-  return {
-    name,
-    type: "decimal",
-    precision: 8,
-    scale: 2,
-    ...option,
-  };
-}
-function boolean(
-  name: string,
-  option?: Omit<BooleanProp, "name" | "type">
-): BooleanProp {
-  return {
-    name,
-    type: "boolean",
-    ...option,
-  };
-}
-function date(
-  name: string,
-  option?: Omit<DateProp, "name" | "type"> & { now?: true }
-): DateProp {
-  if (option?.now === true) {
-    delete option.now;
-    option.dbDefault = "CURRENT_TIMESTAMP";
-  }
-  return {
-    name,
-    type: "date",
-    ...option,
-  };
-}
-function dateTime(
-  name: string,
-  option?: Omit<DateTimeProp, "name" | "type"> & { now?: true }
-): DateTimeProp {
-  if (option?.now === true) {
-    delete option.now;
-    option.dbDefault = "CURRENT_TIMESTAMP";
-  }
-  return {
-    name,
-    type: "datetime",
-    ...option,
-  };
-}
-function time(
-  name: string,
-  option?: Omit<TimeProp, "name" | "type"> & { now?: true }
-): TimeProp {
-  if (option?.now === true) {
-    delete option.now;
-    option.dbDefault = "CURRENT_TIMESTAMP";
-  }
-  return {
-    name,
-    type: "time",
-    ...option,
-  };
-}
-function timestamp(
-  name: string,
-  option?: Omit<TimestampProp, "name" | "type"> & { now?: true }
-): TimestampProp {
-  if (option?.now === true) {
-    delete option.now;
-    option.dbDefault = "CURRENT_TIMESTAMP";
-  }
-  return {
-    name,
-    type: "timestamp",
-    ...option,
-  };
-}
-function json(name: string, option: Omit<JsonProp, "name" | "type">): JsonProp {
-  return {
-    name,
-    type: "json",
-    ...option,
-  };
-}
-function uuid(name: string, option: Omit<UuidProp, "name" | "type">): UuidProp {
-  return {
-    name,
-    type: "uuid",
-    ...option,
-  };
-}
-function enums(
-  name: string,
-  option: Omit<EnumProp, "name" | "type" | "id"> & { id?: string }
-): EnumProp {
-  return {
-    name,
-    type: "enum",
-    id: option.id ?? `$Model${inflection.camelize(name)}`,
-    ...option,
-  };
-}
-function virtual(
-  name: string,
-  option: Omit<VirtualProp, "name" | "type" | "dbDefault" | "toFilter">
-): VirtualProp {
-  return {
-    name,
-    type: "virtual",
-    ...option,
-  };
-}
-function relationOneToOne(
-  name: string,
-  option: DistributiveOmit<
-    OneToOneRelationProp,
-    "name" | "type" | "relationType"
-  >
-): OneToOneRelationProp {
-  return {
-    name,
-    type: "relation",
-    relationType: "OneToOne",
-    ...option,
-  };
-}
-function relationBelongsToOne(
-  name: string,
-  option: Omit<BelongsToOneRelationProp, "name" | "type" | "relationType">
-): BelongsToOneRelationProp {
-  option.useConstraint = (option.useConstraint ?? true) as false;
-  return {
-    name,
-    type: "relation",
-    relationType: "BelongsToOne",
-    ...option,
-  };
-}
-function relationHasMany(
-  name: string,
-  option: Omit<HasManyRelationProp, "name" | "type" | "relationType">
-): HasManyRelationProp {
-  return {
-    name,
-    type: "relation",
-    relationType: "HasMany",
-    ...option,
-  };
-}
-function relationManyToMany(
-  name: string,
-  option: Omit<ManyToManyRelationProp, "name" | "type" | "relationType">
-): ManyToManyRelationProp {
-  return {
-    name,
-    type: "relation",
-    relationType: "ManyToMany",
-    ...option,
-  };
-}
-
-export const i = {
-  index,
-  unique,
-};
-
-function index(columns: string | string[]): EntityIndex {
-  return {
-    type: "index",
-    columns: asArray(columns),
-  };
-}
-
-function unique(columns: string | string[]): EntityIndex {
-  return {
-    type: "unique",
-    columns: asArray(columns),
-  };
-}

package/src/templates/base-template.ts

@@ -1,19 +0,0 @@
-import { TemplateKey, TemplateOptions } from "../types/types";
-import { EntityNamesRecord } from "../entity/entity-manager";
-import { RenderedTemplate } from "../syncer/syncer";
-
-export abstract class Template {
-  constructor(public key: TemplateKey) {}
-  public abstract render(
-    options: TemplateOptions[TemplateKey],
-    ...extra: unknown[]
-  ): RenderedTemplate | Promise<RenderedTemplate>;
-
-  public abstract getTargetAndPath(
-    names?: EntityNamesRecord,
-    ...extra: unknown[]
-  ): {
-    target: string;
-    path: string;
-  };
-}

package/src/templates/generated_sso.template.ts

@@ -1,138 +0,0 @@
-import {
-  isManyToManyRelationProp,
-  SubsetQuery,
-  TemplateOptions,
-} from "../types/types";
-import { EntityManager } from "../entity/entity-manager";
-import { Template } from "./base-template";
-import inflection from "inflection";
-import { SourceCode } from "./generated.template";
-import _ from "lodash";
-import { nonNullable } from "../utils/utils";
-import { Sonamu } from "../api";
-import { Entity } from "../entity/entity";
-
-export class Template__generated_sso extends Template {
-  constructor() {
-    super("generated_sso");
-  }
-
-  getTargetAndPath() {
-    const { dir } = Sonamu.config.api;
-
-    return {
-      target: `${dir}/src/application`,
-      path: `sonamu.generated.sso.ts`,
-    };
-  }
-
-  render({}: TemplateOptions["generated_sso"]) {
-    const entityIds = EntityManager.getAllIds();
-    const entities = entityIds.map((id) => EntityManager.get(id));
-
-    const sourceCodes: SourceCode[] = entities
-      .map((entity) => {
-        if (
-          entity.parentId !== undefined ||
-          Object.keys(entity.subsets).length === 0
-        ) {
-          return null;
-        }
-        const subsetKeys = Object.keys(entity.subsets);
-        const subsetQueryObject = subsetKeys.reduce(
-          (r, subsetKey) => {
-            const subsetQuery = entity.getSubsetQuery(subsetKey);
-            r[subsetKey] = subsetQuery;
-            return r;
-          },
-          {} as {
-            [key: string]: SubsetQuery;
-          }
-        );
-
-        const subsetKeyTypeName = `${entity.names.module}SubsetKey`;
-        return {
-          label: `SubsetQuery: ${entity.id}`,
-          lines: [
-            `export const ${inflection.camelize(
-              entity.id,
-              true
-            )}SubsetQueries:{ [key in ${subsetKeyTypeName}]: SubsetQuery} = ${JSON.stringify(
-              subsetQueryObject
-            )};`,
-            "",
-          ],
-          importKeys: [subsetKeyTypeName],
-        };
-      })
-      .filter(nonNullable);
-
-    // DatabaseSchema 생성
-    const dbSchemaSourceCode = this.getDatabaseSchemaSourceCode(entities);
-    if (dbSchemaSourceCode) {
-      sourceCodes.push(dbSchemaSourceCode);
-    }
-
-    const sourceCode = sourceCodes.reduce(
-      (result, ts) => {
-        if (ts === null) {
-          return result;
-        }
-        return {
-          lines: [...result!.lines, `// ${ts.label}`, ...ts.lines, ""],
-          importKeys: _.uniq([...result!.importKeys, ...ts.importKeys]),
-        };
-      },
-      {
-        lines: [],
-        importKeys: [],
-      } as Omit<SourceCode, "label">
-    );
-
-    const body = sourceCode.lines.join("\n");
-    const isUsingManyToManyBaseSchema = body.includes("ManyToManyBaseSchema");
-    return {
-      ...this.getTargetAndPath(),
-      body: sourceCode.lines.join("\n"),
-      importKeys: sourceCode.importKeys,
-      customHeaders: [
-        `import { SubsetQuery, ${isUsingManyToManyBaseSchema ? "ManyToManyBaseSchema" : ""} } from "sonamu";`,
-      ],
-    };
-  }
-
-  getDatabaseSchemaSourceCode(entities: Entity[]): SourceCode | null {
-    if (entities.length === 0) {
-      return null;
-    }
-
-    const entitySchemaLines = entities.map(
-      (entity) => `${entity.table}: ${entity.id}BaseSchema;`
-    );
-
-    const joinTableSchemaLines = _.uniq(
-      entities.flatMap((entity) =>
-        entity.props.filter(isManyToManyRelationProp).map((prop) => {
-          const fromTableKey = inflection.singularize(entity.table);
-          const toTableKey = inflection.singularize(
-            EntityManager.get(prop.with).table
-          );
-          return `${prop.joinTable}: ManyToManyBaseSchema<"${fromTableKey}", "${toTableKey}">;`;
-        })
-      )
-    );
-
-    return {
-      label: `DatabaseSchema`,
-      lines: [
-        `declare module "sonamu" {`,
-        `  export interface DatabaseSchemaExtend {`,
-        ...entitySchemaLines,
-        ...joinTableSchemaLines,
-        `  }`,
-        `}`,
-      ],
-      importKeys: entities.map((entity) => `${entity.id}BaseSchema`),
-    };
-  }
-}

package/src/templates/index.ts

@@ -1 +0,0 @@
-export * from "./base-template";