drizzle-kit 0.28.1-ddb97ec → 0.29.0-0c27176

package/utils.js

@@ -899,30 +899,30 @@ var supports_color_default = supportsColor;
 
 // ../node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/utilities.js
 function stringReplaceAll(string, substring, replacer) {
-  let index4 = string.indexOf(substring);
-  if (index4 === -1) {
+  let index5 = string.indexOf(substring);
+  if (index5 === -1) {
     return string;
   }
   const substringLength = substring.length;
   let endIndex = 0;
   let returnValue = "";
   do {
-    returnValue += string.slice(endIndex, index4) + substring + replacer;
-    endIndex = index4 + substringLength;
-    index4 = string.indexOf(substring, endIndex);
-  } while (index4 !== -1);
+    returnValue += string.slice(endIndex, index5) + substring + replacer;
+    endIndex = index5 + substringLength;
+    index5 = string.indexOf(substring, endIndex);
+  } while (index5 !== -1);
   returnValue += string.slice(endIndex);
   return returnValue;
 }
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index4) {
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index5) {
   let endIndex = 0;
   let returnValue = "";
   do {
-    const gotCR = string[index4 - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index4 - 1 : index4) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-    endIndex = index4 + 1;
-    index4 = string.indexOf("\n", endIndex);
-  } while (index4 !== -1);
+    const gotCR = string[index5 - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index5 - 1 : index5) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index5 + 1;
+    index5 = string.indexOf("\n", endIndex);
+  } while (index5 !== -1);
   returnValue += string.slice(endIndex);
   return returnValue;
 }
@@ -3175,9 +3175,9 @@ var ZodArray = class _ZodArray extends ZodType {
     return this.min(1, message);
   }
 };
-ZodArray.create = (schema3, params) => {
+ZodArray.create = (schema4, params) => {
   return new ZodArray({
-    type: schema3,
+    type: schema4,
     minLength: null,
     maxLength: null,
     exactLength: null,
@@ -3185,30 +3185,30 @@ ZodArray.create = (schema3, params) => {
     ...processCreateParams(params)
   });
 };
-function deepPartialify(schema3) {
-  if (schema3 instanceof ZodObject) {
+function deepPartialify(schema4) {
+  if (schema4 instanceof ZodObject) {
     const newShape = {};
-    for (const key in schema3.shape) {
-      const fieldSchema = schema3.shape[key];
+    for (const key in schema4.shape) {
+      const fieldSchema = schema4.shape[key];
       newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
     }
     return new ZodObject({
-      ...schema3._def,
+      ...schema4._def,
       shape: () => newShape
     });
-  } else if (schema3 instanceof ZodArray) {
+  } else if (schema4 instanceof ZodArray) {
     return new ZodArray({
-      ...schema3._def,
-      type: deepPartialify(schema3.element)
+      ...schema4._def,
+      type: deepPartialify(schema4.element)
     });
-  } else if (schema3 instanceof ZodOptional) {
-    return ZodOptional.create(deepPartialify(schema3.unwrap()));
-  } else if (schema3 instanceof ZodNullable) {
-    return ZodNullable.create(deepPartialify(schema3.unwrap()));
-  } else if (schema3 instanceof ZodTuple) {
-    return ZodTuple.create(schema3.items.map((item) => deepPartialify(item)));
+  } else if (schema4 instanceof ZodOptional) {
+    return ZodOptional.create(deepPartialify(schema4.unwrap()));
+  } else if (schema4 instanceof ZodNullable) {
+    return ZodNullable.create(deepPartialify(schema4.unwrap()));
+  } else if (schema4 instanceof ZodTuple) {
+    return ZodTuple.create(schema4.items.map((item) => deepPartialify(item)));
   } else {
-    return schema3;
+    return schema4;
   }
 }
 var ZodObject = class _ZodObject extends ZodType {
@@ -3425,8 +3425,8 @@ var ZodObject = class _ZodObject extends ZodType {
   //   }) as any;
   //   return merged;
   // }
-  setKey(key, schema3) {
-    return this.augment({ [key]: schema3 });
+  setKey(key, schema4) {
+    return this.augment({ [key]: schema4 });
   }
   // merge<Incoming extends AnyZodObject>(
   //   merging: Incoming
@@ -3449,10 +3449,10 @@ var ZodObject = class _ZodObject extends ZodType {
   //   }) as any;
   //   return merged;
   // }
-  catchall(index4) {
+  catchall(index5) {
     return new _ZodObject({
       ...this._def,
-      catchall: index4
+      catchall: index5
     });
   }
   pick(mask) {
@@ -3770,9 +3770,9 @@ function mergeValues(a, b) {
       return { valid: false };
     }
     const newArray = [];
-    for (let index4 = 0; index4 < a.length; index4++) {
-      const itemA = a[index4];
-      const itemB = b[index4];
+    for (let index5 = 0; index5 < a.length; index5++) {
+      const itemA = a[index5];
+      const itemB = b[index5];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
         return { valid: false };
@@ -3872,10 +3872,10 @@ var ZodTuple = class _ZodTuple extends ZodType {
       status.dirty();
     }
     const items = [...ctx.data].map((item, itemIndex) => {
-      const schema3 = this._def.items[itemIndex] || this._def.rest;
-      if (!schema3)
+      const schema4 = this._def.items[itemIndex] || this._def.rest;
+      if (!schema4)
         return null;
-      return schema3._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+      return schema4._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
     }).filter((x) => !!x);
     if (ctx.common.async) {
       return Promise.all(items).then((results) => {
@@ -3978,10 +3978,10 @@ var ZodMap = class extends ZodType {
     }
     const keyType = this._def.keyType;
     const valueType = this._def.valueType;
-    const pairs = [...ctx.data.entries()].map(([key, value], index4) => {
+    const pairs = [...ctx.data.entries()].map(([key, value], index5) => {
       return {
-        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index4, "key"])),
-        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index4, "value"]))
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index5, "key"])),
+        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index5, "value"]))
       };
     });
     if (ctx.common.async) {
@@ -4409,9 +4409,9 @@ var ZodPromise = class extends ZodType {
     }));
   }
 };
-ZodPromise.create = (schema3, params) => {
+ZodPromise.create = (schema4, params) => {
   return new ZodPromise({
-    type: schema3,
+    type: schema4,
     typeName: ZodFirstPartyTypeKind.ZodPromise,
     ...processCreateParams(params)
   });
@@ -4536,17 +4536,17 @@ var ZodEffects = class extends ZodType {
     util.assertNever(effect);
   }
 };
-ZodEffects.create = (schema3, effect, params) => {
+ZodEffects.create = (schema4, effect, params) => {
   return new ZodEffects({
-    schema: schema3,
+    schema: schema4,
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     effect,
     ...processCreateParams(params)
   });
 };
-ZodEffects.createWithPreprocess = (preprocess, schema3, params) => {
+ZodEffects.createWithPreprocess = (preprocess, schema4, params) => {
   return new ZodEffects({
-    schema: schema3,
+    schema: schema4,
     effect: { type: "preprocess", transform: preprocess },
     typeName: ZodFirstPartyTypeKind.ZodEffects,
     ...processCreateParams(params)
@@ -5520,8 +5520,117 @@ var dryPg = pgSchema.parse({
   }
 });
 
-// src/serializer/sqliteSchema.ts
+// src/serializer/singlestoreSchema.ts
 var index3 = objectType({
+  name: stringType(),
+  columns: stringType().array(),
+  isUnique: booleanType(),
+  using: enumType(["btree", "hash"]).optional(),
+  algorithm: enumType(["default", "inplace", "copy"]).optional(),
+  lock: enumType(["default", "none", "shared", "exclusive"]).optional()
+}).strict();
+var column3 = objectType({
+  name: stringType(),
+  type: stringType(),
+  primaryKey: booleanType(),
+  notNull: booleanType(),
+  autoincrement: booleanType().optional(),
+  default: anyType().optional(),
+  onUpdate: anyType().optional(),
+  generated: objectType({
+    type: enumType(["stored", "virtual"]),
+    as: stringType()
+  }).optional()
+}).strict();
+var compositePK3 = objectType({
+  name: stringType(),
+  columns: stringType().array()
+}).strict();
+var uniqueConstraint3 = objectType({
+  name: stringType(),
+  columns: stringType().array()
+}).strict();
+var table3 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), column3),
+  indexes: recordType(stringType(), index3),
+  compositePrimaryKeys: recordType(stringType(), compositePK3),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
+}).strict();
+var viewMeta2 = objectType({
+  algorithm: enumType(["undefined", "merge", "temptable"]),
+  sqlSecurity: enumType(["definer", "invoker"]),
+  withCheckOption: enumType(["local", "cascaded"]).optional()
+}).strict();
+var kitInternals3 = objectType({
+  tables: recordType(
+    stringType(),
+    objectType({
+      columns: recordType(
+        stringType(),
+        objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
+      )
+    }).optional()
+  ).optional(),
+  indexes: recordType(
+    stringType(),
+    objectType({
+      columns: recordType(
+        stringType(),
+        objectType({ isExpression: booleanType().optional() }).optional()
+      )
+    }).optional()
+  ).optional()
+}).optional();
+var dialect2 = literalType("singlestore");
+var schemaHash3 = objectType({
+  id: stringType(),
+  prevId: stringType()
+});
+var schemaInternal2 = objectType({
+  version: literalType("1"),
+  dialect: dialect2,
+  tables: recordType(stringType(), table3),
+  /* views: record(string(), view).default({}), */
+  _meta: objectType({
+    tables: recordType(stringType(), stringType()),
+    columns: recordType(stringType(), stringType())
+  }),
+  internal: kitInternals3
+}).strict();
+var schema2 = schemaInternal2.merge(schemaHash3);
+var tableSquashed3 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), column3),
+  indexes: recordType(stringType(), stringType()),
+  compositePrimaryKeys: recordType(stringType(), stringType()),
+  uniqueConstraints: recordType(stringType(), stringType()).default({})
+}).strict();
+var schemaSquashed2 = objectType({
+  version: literalType("1"),
+  dialect: dialect2,
+  tables: recordType(stringType(), tableSquashed3)
+  /* views: record(string(), viewSquashed), */
+}).strict();
+var singlestoreSchema = schema2;
+var backwardCompatibleSingleStoreSchema = unionType([singlestoreSchema, schema2]);
+var drySingleStore = singlestoreSchema.parse({
+  version: "1",
+  dialect: "singlestore",
+  id: originUUID,
+  prevId: "",
+  tables: {},
+  schemas: {},
+  /* views: {}, */
+  _meta: {
+    schemas: {},
+    tables: {},
+    columns: {}
+  }
+});
+
+// src/serializer/sqliteSchema.ts
+var index4 = objectType({
   name: stringType(),
   columns: stringType().array(),
   where: stringType().optional(),
@@ -5536,11 +5645,11 @@ var fk3 = objectType({
   onUpdate: stringType().optional(),
   onDelete: stringType().optional()
 }).strict();
-var compositePK3 = objectType({
+var compositePK4 = objectType({
   columns: stringType().array(),
   name: stringType().optional()
 }).strict();
-var column3 = objectType({
+var column4 = objectType({
   name: stringType(),
   type: stringType(),
   primaryKey: booleanType(),
@@ -5554,11 +5663,11 @@ var column3 = objectType({
 }).strict();
 var tableV33 = objectType({
   name: stringType(),
-  columns: recordType(stringType(), column3),
-  indexes: recordType(stringType(), index3),
+  columns: recordType(stringType(), column4),
+  indexes: recordType(stringType(), index4),
   foreignKeys: recordType(stringType(), fk3)
 }).strict();
-var uniqueConstraint3 = objectType({
+var uniqueConstraint4 = objectType({
   name: stringType(),
   columns: stringType().array()
 }).strict();
@@ -5566,50 +5675,50 @@ var checkConstraint3 = objectType({
   name: stringType(),
   value: stringType()
 }).strict();
-var table3 = objectType({
+var table4 = objectType({
   name: stringType(),
-  columns: recordType(stringType(), column3),
-  indexes: recordType(stringType(), index3),
+  columns: recordType(stringType(), column4),
+  indexes: recordType(stringType(), index4),
   foreignKeys: recordType(stringType(), fk3),
-  compositePrimaryKeys: recordType(stringType(), compositePK3),
-  uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({}),
+  compositePrimaryKeys: recordType(stringType(), compositePK4),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint4).default({}),
   checkConstraints: recordType(stringType(), checkConstraint3).default({})
 }).strict();
 var view3 = objectType({
   name: stringType(),
-  columns: recordType(stringType(), column3),
+  columns: recordType(stringType(), column4),
   definition: stringType().optional(),
   isExisting: booleanType()
 }).strict();
-var dialect2 = enumType(["sqlite"]);
-var schemaHash3 = objectType({
+var dialect3 = enumType(["sqlite"]);
+var schemaHash4 = objectType({
   id: stringType(),
   prevId: stringType()
 }).strict();
 var schemaInternalV32 = objectType({
   version: literalType("3"),
-  dialect: dialect2,
+  dialect: dialect3,
   tables: recordType(stringType(), tableV33),
   enums: objectType({})
 }).strict();
 var schemaInternalV42 = objectType({
   version: literalType("4"),
-  dialect: dialect2,
-  tables: recordType(stringType(), table3),
+  dialect: dialect3,
+  tables: recordType(stringType(), table4),
   views: recordType(stringType(), view3).default({}),
   enums: objectType({})
 }).strict();
 var schemaInternalV52 = objectType({
   version: literalType("5"),
-  dialect: dialect2,
-  tables: recordType(stringType(), table3),
+  dialect: dialect3,
+  tables: recordType(stringType(), table4),
   enums: objectType({}),
   _meta: objectType({
     tables: recordType(stringType(), stringType()),
     columns: recordType(stringType(), stringType())
   })
 }).strict();
-var kitInternals3 = objectType({
+var kitInternals4 = objectType({
   indexes: recordType(
     stringType(),
     objectType({
@@ -5621,39 +5730,39 @@ var kitInternals3 = objectType({
   ).optional()
 }).optional();
 var latestVersion = literalType("6");
-var schemaInternal2 = objectType({
+var schemaInternal3 = objectType({
   version: latestVersion,
-  dialect: dialect2,
-  tables: recordType(stringType(), table3),
+  dialect: dialect3,
+  tables: recordType(stringType(), table4),
   views: recordType(stringType(), view3).default({}),
   enums: objectType({}),
   _meta: objectType({
     tables: recordType(stringType(), stringType()),
     columns: recordType(stringType(), stringType())
   }),
-  internal: kitInternals3
+  internal: kitInternals4
 }).strict();
-var schemaV32 = schemaInternalV32.merge(schemaHash3).strict();
-var schemaV42 = schemaInternalV42.merge(schemaHash3).strict();
-var schemaV52 = schemaInternalV52.merge(schemaHash3).strict();
-var schema2 = schemaInternal2.merge(schemaHash3).strict();
-var tableSquashed3 = objectType({
+var schemaV32 = schemaInternalV32.merge(schemaHash4).strict();
+var schemaV42 = schemaInternalV42.merge(schemaHash4).strict();
+var schemaV52 = schemaInternalV52.merge(schemaHash4).strict();
+var schema3 = schemaInternal3.merge(schemaHash4).strict();
+var tableSquashed4 = objectType({
   name: stringType(),
-  columns: recordType(stringType(), column3),
+  columns: recordType(stringType(), column4),
   indexes: recordType(stringType(), stringType()),
   foreignKeys: recordType(stringType(), stringType()),
   compositePrimaryKeys: recordType(stringType(), stringType()),
   uniqueConstraints: recordType(stringType(), stringType()).default({}),
   checkConstraints: recordType(stringType(), stringType()).default({})
 }).strict();
-var schemaSquashed2 = objectType({
+var schemaSquashed3 = objectType({
   version: latestVersion,
-  dialect: dialect2,
-  tables: recordType(stringType(), tableSquashed3),
+  dialect: dialect3,
+  tables: recordType(stringType(), tableSquashed4),
   views: recordType(stringType(), view3),
   enums: anyType()
 }).strict();
-var drySQLite = schema2.parse({
+var drySQLite = schema3.parse({
   version: "6",
   dialect: "sqlite",
   id: originUUID,
@@ -5667,7 +5776,7 @@ var drySQLite = schema2.parse({
   }
 });
 var sqliteSchemaV5 = schemaV52;
-var backwardCompatibleSqliteSchema = unionType([sqliteSchemaV5, schema2]);
+var backwardCompatibleSqliteSchema = unionType([sqliteSchemaV5, schema3]);
 
 // src/utils.ts
 var copy = (it) => {
@@ -5691,27 +5800,27 @@ var assertV1OutFolder = (out) => {
     process.exit(1);
   }
 };
-var dryJournal = (dialect3) => {
+var dryJournal = (dialect4) => {
   return {
     version: snapshotVersion,
-    dialect: dialect3,
+    dialect: dialect4,
     entries: []
   };
 };
-var prepareOutFolder = (out, dialect3) => {
+var prepareOutFolder = (out, dialect4) => {
   const meta = (0, import_path.join)(out, "meta");
   const journalPath = (0, import_path.join)(meta, "_journal.json");
   if (!(0, import_fs.existsSync)((0, import_path.join)(out, "meta"))) {
     (0, import_fs.mkdirSync)(meta, { recursive: true });
-    (0, import_fs.writeFileSync)(journalPath, JSON.stringify(dryJournal(dialect3)));
+    (0, import_fs.writeFileSync)(journalPath, JSON.stringify(dryJournal(dialect4)));
   }
   const journal = JSON.parse((0, import_fs.readFileSync)(journalPath).toString());
   const snapshots = (0, import_fs.readdirSync)(meta).filter((it) => !it.startsWith("_")).map((it) => (0, import_path.join)(meta, it));
   snapshots.sort();
   return { meta, snapshots, journal };
 };
-var validatorForDialect = (dialect3) => {
-  switch (dialect3) {
+var validatorForDialect = (dialect4) => {
+  switch (dialect4) {
     case "postgresql":
       return { validator: backwardCompatiblePgSchema, version: 7 };
     case "sqlite":
@@ -5720,10 +5829,12 @@ var validatorForDialect = (dialect3) => {
       return { validator: backwardCompatibleSqliteSchema, version: 6 };
     case "mysql":
       return { validator: backwardCompatibleMysqlSchema, version: 5 };
+    case "singlestore":
+      return { validator: backwardCompatibleSingleStoreSchema, version: 1 };
   }
 };
-var validateWithReport = (snapshots, dialect3) => {
-  const { validator, version } = validatorForDialect(dialect3);
+var validateWithReport = (snapshots, dialect4) => {
+  const { validator, version } = validatorForDialect(dialect4);
   const result = snapshots.reduce(
     (accum, it) => {
       const raw = JSON.parse((0, import_fs.readFileSync)(`./${it}`).toString());
@@ -5764,9 +5875,9 @@ var validateWithReport = (snapshots, dialect3) => {
   );
   return result;
 };
-var prepareMigrationFolder = (outFolder = "drizzle", dialect3) => {
-  const { snapshots, journal } = prepareOutFolder(outFolder, dialect3);
-  const report = validateWithReport(snapshots, dialect3);
+var prepareMigrationFolder = (outFolder = "drizzle", dialect4) => {
+  const { snapshots, journal } = prepareOutFolder(outFolder, dialect4);
+  const report = validateWithReport(snapshots, dialect4);
   if (report.nonLatest.length > 0) {
     console.log(
       report.nonLatest.map((it) => {
@@ -5829,8 +5940,8 @@ var tableRenameKey = (it) => {
   const out = it.schema ? `"${it.schema}"."${it.name}"` : `"${it.name}"`;
   return out;
 };
-var columnRenameKey = (table4, schema3, column4) => {
-  const out = schema3 ? `"${schema3}"."${table4}"."${column4}"` : `"${table4}"."${column4}"`;
+var columnRenameKey = (table5, schema4, column5) => {
+  const out = schema4 ? `"${schema4}"."${table5}"."${column5}"` : `"${table5}"."${column5}"`;
   return out;
 };
 var kloudMeta = () => {